/*
 * Copyright (c) 2017 The openGion Project.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.opengion.fukurou.fileexec;

// import java.io.File;
import java.io.IOException;

import java.nio.file.WatchEvent;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;                                                       // 7.4.4.0 (2021/06/30)
import java.nio.file.WatchKey;
import java.nio.file.StandardWatchEventKinds;
import java.nio.file.WatchService;

import java.util.function.BiConsumer;
// import java.util.concurrent.atomic.AtomicBoolean;            // 7.2.9.4 (2020/11/20) volatile boolean の代替え , // 7.4.4.0 (2021/06/30) 戻す

/**
 * FileWatch は、ﾌｧｲﾙ監視を行うｸﾗｽです。
 *
 *<pre>
 * ﾌｧｲﾙが、追加(作成)、変更、削除された場合に、ｲﾍﾞﾝﾄが発生します。
 * このｸﾗｽは、Runnable ｲﾝﾀｰﾌｪｰｽを実装しているため、Thread で実行することで、
 * 個々のﾌｫﾙﾀﾞの監視を行います。
 *
 *</pre>
 * @og.rev 7.0.0.0 (2017/07/07) 新規作成
 *
 * @version  7.0
 * @author   Kazuhiko Hasegawa
 * @since    JDK1.8,
 */
public class FileWatch implements Runnable {
        private static final XLogger LOGGER= XLogger.getLogger( FileWatch.class.getSimpleName() );              // ﾛｸﾞ出力

        /** Path に、WatchService を register するときの作成ｲﾍﾞﾝﾄの簡易指定できるように。 */
        public static final WatchEvent.Kind<Path> CREATE = StandardWatchEventKinds.ENTRY_CREATE ;

        /** Path に、WatchService を register するときの変更ｲﾍﾞﾝﾄの簡易指定できるように。 */
        public static final WatchEvent.Kind<Path> MODIFY = StandardWatchEventKinds.ENTRY_MODIFY ;

        /** Path に、WatchService を register するときの削除ｲﾍﾞﾝﾄの簡易指定できるように。 */
        public static final WatchEvent.Kind<Path> DELETE = StandardWatchEventKinds.ENTRY_DELETE ;

        /** Path に、WatchService を register するときの特定不能時ｲﾍﾞﾝﾄの簡易指定できるように。 */
        public static final WatchEvent.Kind<?>    OVERFLOW = StandardWatchEventKinds.OVERFLOW ;

        /** Path に、WatchService を register するときのｲﾍﾞﾝﾄ */
        // 8.5.4.2 (2024/01/12) PMD 7.0.0 UseShortArrayInitializer
//      private static final WatchEvent.Kind<?>[] WE_KIND = new WatchEvent.Kind<?>[] { CREATE , MODIFY , DELETE , OVERFLOW };
        private static final WatchEvent.Kind<?>[] WE_KIND = { CREATE , MODIFY , DELETE , OVERFLOW };

        /** Path に、WatchService を register するときの登録方法の修飾子(修飾子 なしの場合) */
        private static final WatchEvent.Modifier[] WE_MOD_ONE  = new WatchEvent.Modifier[0];    // Modifier なし

        /** Path に、WatchService を register するときの登録方法の修飾子(以下の階層も監視対象にします) */
        // 8.5.4.2 (2024/01/12) PMD 7.0.0 UseShortArrayInitializer
//      private static final WatchEvent.Modifier[] WE_MOD_TREE = new WatchEvent.Modifier[] {    // ﾂﾘｰ階層
        private static final WatchEvent.Modifier[] WE_MOD_TREE = {                      // ﾂﾘｰ階層
                // 8.5.3.3 (2023/10/27) 警告: ExtendedWatchEventModifierは内部所有のAPIであり、今後のリリースで削除される可能性があります
//              com.sun.nio.file.ExtendedWatchEventModifier.FILE_TREE
                () -> "FILE_TREE"                       // interface java.nio.file.WatchEvent.Modifier をﾗﾑﾀﾞ式で表現
        };

        /** DirWatch でｽｷｬﾝした場合のｲﾍﾞﾝﾄ名 {@value} */
        public static final String DIR_WATCH_EVENT = "DirWatch";

        /** 7.4.4.0 (2021/06/30) stop() してから、実際に止まるまで 待機する時間 (ms ) */
        public static final int STOP_WATI_TIME = 500 ;

        /** 7.4.4.0 (2021/06/30) stop() してから、実際に止まるまで 待機する回数 */
        public static final int STOP_WATI_CNT = 5 ;

        /** 監視対象のﾌｫﾙﾀﾞ */
        private final Path dirPath ;

        /** 監視方法 */
        private final boolean   useTree ;
        private final WatchEvent.Modifier[] extModifiers ;

        /** callbackするための、関数型ｲﾝﾀｰﾌｪｰｽ(ﾒｿｯﾄﾞ参照) */
        private BiConsumer<String,Path> action = (event,path) -> System.out.println( "Event=" + event + " , Path=" + path ) ;

        /** Path に、WatchService を register するときのｲﾍﾞﾝﾄ */
        private WatchEvent.Kind<?>[] weKind = WE_KIND ;                                         // 初期値は、すべて

        /** ﾊﾟｽの照合操作を行うPathMatcher の初期値 */
        private final PathMatcherSet pathMchSet = new PathMatcherSet();         // PathMatcher ｲﾝﾀｰﾌｪｰｽを継承

        /** DirWatchのﾊﾟｽの照合操作を行うPathMatcher の初期値 */
        private final PathMatcherSet dirWatchMch = new PathMatcherSet();        // PathMatcher ｲﾝﾀｰﾌｪｰｽを継承

        /** 何らかの原因でｲﾍﾞﾝﾄもれした場合、ﾌｫﾙﾀﾞｽｷｬﾝを行います。 */
        private boolean         useDirWatch     = true;                                                         // 初期値は、ｲﾍﾞﾝﾄ漏れ監視を行います。
        private DirWatch        dWatch ;                                                                                // DirWatch のstop時に呼び出すための変数
        private Thread          thread ;                                                                                // 停止するときに呼び出すため

        /** 状態とThreadの停止に使用する。 */
        private boolean running ;                                                                                       // 8.5.4.2 (2024/01/12) 無しでもいいか…
//      private volatile boolean running ;                                                                      // 状態とThreadの停止に使用する。 // 7.4.4.0 (2021/06/30) 復活
//      private final AtomicBoolean running = new AtomicBoolean();                      // 7.2.9.4 (2020/11/20) volatile boolean の代替え ( 状態とThreadの停止に使用する。)

        /**
         * 処理対象のﾌｫﾙﾀﾞのﾊﾟｽｵﾌﾞｼﾞｪｸﾄを指定して、ﾌｧｲﾙ監視ｲﾝｽﾀﾝｽを作成します。
         *
         * ここでは、指定のﾌｫﾙﾀﾞの内のﾌｧｲﾙのみ監視します。
         * これは、new FileWatch( dir , false ) とまったく同じです。
         *
         * @param dir   処理対象のﾌｫﾙﾀﾞｵﾌﾞｼﾞｪｸﾄ
         */
        public FileWatch( final Path dir ) {
                this( dir , false );
        }

        /**
         * 処理対象のﾌｫﾙﾀﾞのﾊﾟｽｵﾌﾞｼﾞｪｸﾄと、監視対象方法を指定して、ﾌｧｲﾙ監視ｲﾝｽﾀﾝｽを作成します。
         *
         * useTree を true に設定すると、指定のﾌｫﾙﾀﾞの内のﾌｫﾙﾀﾞ階層を、すべて監視対象とします。
         *
         * @param dir   処理対象のﾌｫﾙﾀﾞのﾊﾟｽｵﾌﾞｼﾞｪｸﾄ
         * @param useTree       ﾌｫﾙﾀﾞﾂﾘｰの階層をさかのぼって監視するかどうか(true:ﾌｫﾙﾀﾞ階層を下る)
         */
        public FileWatch( final Path dir , final boolean useTree ) {
                dirPath          = dir ;
                this.useTree = useTree;
                extModifiers = useTree ? WE_MOD_TREE : WE_MOD_ONE ;
        }

        /**
         * 指定のｲﾍﾞﾝﾄの種類のみ、監視対象に設定します。
         *
         * ここで指定したｲﾍﾞﾝﾄのみ、監視対象になり、callback されます。
         * 第一引数は、ｲﾍﾞﾝﾄの種類(ENTRY_CREATE,ENTRY_MODIFY,ENTRY_DELETE,OVERFLOW)
         *
         * @param       kind 監視対象に設定するｲﾍﾞﾝﾄの種類
         * @see         java.nio.file.StandardWatchEventKinds
         */
        public void setEventKinds( final WatchEvent.Kind<?>... kind ) {
                if( kind != null && kind.length > 0 ) {
                        weKind = kind;
                }
        }

        /**
         * 指定のﾊﾟｽの照合操作で、ﾊﾟﾀｰﾝに一致したﾊﾟｽのみ、callback されます。
         *
         * ここで指定したﾊﾟﾀｰﾝの一致を判定し、一致した場合は、callback されます。
         * 指定しない場合は、すべて許可されたことになります。
         * なお、#setPathEndsWith(String...) と、この設定は同時には行うことは出来ません。
         * (最後に登録した条件が、適用されます。)
         *
         * @param       pathMch ﾊﾟｽの照合操作のﾊﾟﾀｰﾝ
         * @see         java.nio.file.PathMatcher
         * @see         #setPathEndsWith(String...)
         */
        public void setPathMatcher( final PathMatcher pathMch ) {
                pathMchSet.addPathMatcher( pathMch );
        }

        /**
         * 指定のﾊﾟｽが、指定の文字列と、終端一致(endsWith) したﾊﾟｽのみ、callback されます。
         *
         * これは、#setPathMatcher(PathMatcher) の簡易指定版です。
         * 指定の終端文字列(一般には拡張子)のうち、ひとつでも一致すれば、true となりcallback されます。
         * 指定しない場合(null)は、すべて許可されたことになります。
         * 終端文字列の判定には、大文字小文字の区別を行いません。
         * なお、#setPathMatcher(PathMatcher) と、この設定は同時には行うことは出来ません。
         * (最後に登録した条件が、適用されます。)
         *
         * @param       endKey ﾊﾟｽの終端一致のﾊﾟﾀｰﾝ
         * @see         #setPathMatcher(PathMatcher)
         */
        public void setPathEndsWith( final String... endKey ) {
                pathMchSet.addEndsWith( endKey );
        }

        /**
         * ｲﾍﾞﾝﾄの種類と、ﾌｧｲﾙﾊﾟｽを、引数に取る BiConsumer ﾀﾞｵﾌﾞｼﾞｪｸﾄを設定します。
         *
         * これは、関数型ｲﾝﾀﾌｪｰｽなので、ﾗﾑﾀﾞ式またはﾒｿｯﾄﾞ参照の代入先として使用できます。
         * ｲﾍﾞﾝﾄが発生したときの ｲﾍﾞﾝﾄの種類と、そのﾌｧｲﾙﾊﾟｽを引数に、accept(String,Path) ﾒｿｯﾄﾞが呼ばれます。
         * 第一引数は、ｲﾍﾞﾝﾄの種類(ENTRY_CREATE,ENTRY_MODIFY,ENTRY_DELETE,OVERFLOW)
         * 第二引数は、ﾌｧｲﾙﾊﾟｽ(監視ﾌｫﾙﾀﾞで、resolveされた、正式なﾌﾙﾊﾟｽ)
         *
         * @param       act 2つの入力(ｲﾍﾞﾝﾄの種類 とﾌｧｲﾙﾊﾟｽ) を受け取る関数型ｲﾝﾀﾌｪｰｽ
         * @see         BiConsumer#accept(Object,Object)
         */
        public void callback( final BiConsumer<String,Path> act ) {
                if( act != null ) {
                        action = act ;
                }
        }

        /**
         * 何らかの原因でｲﾍﾞﾝﾄを掴み損ねた場合に、ﾌｫﾙﾀﾞｽｷｬﾝするかどうかを指定します。
         *
         * ｽｷｬﾝ開始の遅延時間と、ｽｷｬﾝ間隔、ﾌｧｲﾙのﾀｲﾑｽﾀﾝﾌﾟとの比較時間等は、
         * DirWatch の初期値をそのまま使用するため、ここでは指定できません。
         * 個別に指定したい場合は、このﾌﾗｸﾞをfalse にｾｯﾄして、個別に、DirWatch を作成してください。
         * このﾒｿｯﾄﾞでは、#setPathEndsWith( String... )や、#setPathMatcher( PathMatcher ) で
         * 指定した条件が、そのまま適用されます。
         *
         * @param       flag ﾌｫﾙﾀﾞｽｷｬﾝするかどうか(true:する/false:しない)
         * @see         DirWatch
         */
        public void setUseDirWatch( final boolean flag ) {
                useDirWatch = flag;
        }

        /**
         * 何らかの原因でｲﾍﾞﾝﾄを掴み損ねた場合の、ﾌｫﾙﾀﾞｽｷｬﾝの対象ﾌｧｲﾙの拡張子を指定します。
         *
         * このﾒｿｯﾄﾞを使用する場合は、useDirWatch は、true にｾｯﾄされます。
         * ｽｷｬﾝ開始の遅延時間と、ｽｷｬﾝ間隔、ﾌｧｲﾙのﾀｲﾑｽﾀﾝﾌﾟとの比較時間等は、
         * DirWatch の初期値をそのまま使用するため、ここでは指定できません。
         * このﾒｿｯﾄﾞでは、DirWatch 対象の終端ﾊﾟﾀｰﾝを独自に指定できますが、FileWatch で
         * で指定した条件も、ｸﾘｱされるので、含める必要があります。
         *
         * @param       endKey ﾊﾟｽの終端一致のﾊﾟﾀｰﾝ
         * @see         DirWatch
         */
        public void setDirWatchEndsWith( final String... endKey ) {
                if( endKey != null && endKey.length > 0 ) {
                        useDirWatch = true;                                     // 対象があれば、実行するが、true になる。

                        dirWatchMch.addEndsWith( endKey );
                }
        }

        /**
         * このﾌｧｲﾙ監視で、最後に処理した結果が、ｴﾗｰの場合に、true を返します。
         *
         * 通常は、対象ﾌｫﾙﾀﾞが見つからない場合や、ﾌｫﾙﾀﾞｽｷｬﾝ（DirWatch）で
         * ｴﾗｰが発生した場合に、true にｾｯﾄされます。
         * また、stop() ﾒｿｯﾄﾞが呼ばれた場合も、true にｾｯﾄされます。
         *
         * @og.rev 7.2.9.4 (2020/11/20) PMD:volatile boolean の代替え。
         *
         * @return      ｴﾗｰ状態(true:ｴﾗｰ,false:正常)
         */
        public boolean isErrorStatus() {
                // DirWatch を使用している場合は、その結果も加味します。
//              return isError || dWatch != null && dWatch.isErrorStatus() ;
//              return !running.get() || dWatch != null && dWatch.isErrorStatus() ;             // 7.2.9.4 (2020/11/20)
                return !running || dWatch != null && dWatch.isErrorStatus() ;                   // 7.4.4.0 (2021/06/30) 復活
        }

        /**
         * ﾌｫﾙﾀﾞの監視を開始します。
         *
         * @og.rev 7.2.9.4 (2020/11/20) PMD:volatile boolean の代替え。
         * @og.rev 7.4.4.0 (2021/06/30) stop() してから、実際に止まるまでの時間、待機します。
         * @og.rev 8.1.0.3 (2022/01/21) ｽﾚｯﾄﾞに名前を付けておきます。
         *
         * 自身を、Threadに登録して、Thread#start() を実行します。
         * 内部の Thread ｵﾌﾞｼﾞｪｸﾄがなければ、新しく作成します。
         * すでに、実行中の場合は、何もしません。
         * 条件を変えて、実行したい場合は、stop() ﾒｿｯﾄﾞで、一旦ｽﾚｯﾄﾞを
         * 停止させてから、再び、#start() ﾒｿｯﾄﾞを呼び出してください。
         */
        public void start() {
                // 7.4.4.0 (2021/06/30) stop() してから、実際に止まるまでの時間、待機します。
                int cnt = 0;
                while( running ) {
                        cnt++ ;
//                      try{ Thread.sleep( STOP_WATI_TIME ); } catch( final InterruptedException ex ){}
                        try { Thread.sleep( STOP_WATI_TIME ); } catch( final InterruptedException ignored ) {}  // 8.5.4.2 (2024/01/12) PMD 7.0.0 EmptyCatchBlock
                        if( cnt >= STOP_WATI_CNT ) {    // ﾙｰﾌﾟ後も、まだ、stop() 出来ていない場合。
                                LOGGER.warning( () -> "FileWatch Stop Error : [" + dirPath + "]" );
                        }
                }

                running = true;                         // 7.4.4.0 (2021/06/30) 復活

                if( thread == null ) {
//                      thread = new Thread( this );
                        thread = new Thread( this,"FileWatch" );                // 8.1.0.3 (2022/01/21)
//                      running = true;
//                      running.set( true );    // 7.2.9.4 (2020/11/20)
                        thread.start();                 // running=true; を先に行わないと、すぐに終了してしまう。
                }

                // 監視漏れのﾌｧｲﾙを、一定時間でｽｷｬﾝする
                if( useDirWatch ) {
                        dWatch = new DirWatch( dirPath,useTree );
                        if( dirWatchMch.isEmpty() ) {                   // 初期値は、未登録時は、本体と同じPathMatcher を使用します。
                                dWatch.setPathMatcher( pathMchSet );
                        }
                        else {
                                dWatch.setPathMatcher( dirWatchMch );
                        }
                        dWatch.callback( path -> action.accept( DIR_WATCH_EVENT , path ) ) ;    // BiConsumer<String,Path> を Consumer<Path> に変換しています。
                        dWatch.start();
                }
        }

        /**
         * ﾌｫﾙﾀﾞの監視を終了します。
         *
         * 自身を登録しているThreadに、割り込みをかけるため、
         * Thread#interrupt() を実行します。
         * ﾌｫﾙﾀﾞ監視は、ﾌｧｲﾙ変更ｲﾍﾞﾝﾄが発生するまで待機していますが、
         * interrupt() を実行すると、強制的に中断できます。
         * 内部の Thread ｵﾌﾞｼﾞｪｸﾄは、破棄するため、再び、start() ﾒｿｯﾄﾞで
         * 実行再開することが可能です。
         *
         * @og.rev 7.2.9.4 (2020/11/20) PMD:volatile boolean の代替え。
         * @og.rev 7.4.4.0 (2021/06/30) thread の存在有無にかかわらず、running は停止状態にする。
         */
        public void stop() {
                // 7.4.4.0 (2021/06/30) thread の存在有無にかかわらず、running は停止状態にする。
                running = false;                // 7.4.4.0 (2021/06/30) 復活

                if( thread != null ) {
//                      running = false;
        //              running.set( false );           // 7.2.9.4 (2020/11/20)
                        thread.interrupt();
        //              thread = null;                  1.1.0 (2018/02/01) stop() 時に null を入れると、interrupt() 後の処理が継続できなくなる。
        //              なので、run()の最後に、thread = null を入れておきます。
                }

                if( dWatch != null ) {
                        dWatch.stop();
                        dWatch = null;
                }
        }

        /**
         * Runnableｲﾝﾀｰﾌｪｰｽのrunﾒｿｯﾄﾞです。
         *
         * 規定のｽｹｼﾞｭｰﾙ時刻が来ると、呼ばれる runﾒｿｯﾄﾞです。
         *
         * @og.rev 7.2.5.0 (2020/06/01) LOGGERを使用します。
         * @og.rev 7.2.9.4 (2020/11/20) PMD:volatile boolean の代替え。
         */
        @Override       // Runnable
        public void run() {
                try {
                        execute();
                }
                catch( final IOException ex ) {
                        // MSG0102 = ﾌｧｲﾙ監視に失敗しました。 Path=[{0}]
//                      MsgUtil.errPrintln( ex , "MSG0102" , dirPath );
                        final String errMsg = "FileWatch#run : Path=" + dirPath ;
                        LOGGER.warning( ex , "MSG0102" , errMsg );
                }
                catch( final Throwable th ) {
                        // MSG0021 = 予期せぬｴﾗｰが発生しました。\n\tﾒｯｾｰｼﾞ=[{0}]
//                      MsgUtil.errPrintln( th , "MSG0021" , toString() );
                        final String errMsg = "FileWatch#run : Path=" + dirPath ;
                        LOGGER.warning( th , "MSG0021" , errMsg );
                }
                finally {
                        running = false;                        // 7.4.4.0 (2021/06/30) 停止条件だが、予期せぬｴﾗｰで停止した場合も、設定する。
                        thread  = null;                         // 7.2.5.0 (2020/06/01) 停止処理
//                      running = false;
//                      running.set( false );           // 7.2.9.4 (2020/11/20)
                }
        }

        /**
         * runﾒｿｯﾄﾞから呼ばれる、実際の処理。
         *
         * try ･･･ catch( Throwable ) 構文を、runﾒｿｯﾄﾞの標準的な作りにしておきたいため、
         * あえて、実行ﾒｿｯﾄﾞを分けているだけです。
         *
         * @og.rev 6.8.1.5 (2017/09/08) LOGGER.debug 情報の追加
         * @og.rev 7.2.9.4 (2020/11/20) PMD:volatile boolean の代替え
         * @og.rev 8.0.0.0 (2021/07/01) dirPathのsynchronized作成
         *
         * @throws IOException 入出力実行でｴﾗｰが出た場合
         */
        private void execute() throws IOException {
                // ﾌｧｲﾙ監視などの機能は新しいNIO2ｸﾗｽで拡張されたので
                // 旧File型から、新しいPath型に変換する.
                LOGGER.info( () -> "FileWatch Start: " + dirPath );

                // ﾃﾞﾌｫﾙﾄのﾌｧｲﾙ・ｼｽﾃﾑを閉じることはできません。(UnsupportedOperationException がｽﾛｰされる)
                // なので、try-with-resources 文 (AutoCloseable) に、入れません。
//              final FileSystem fs = dirPath.getFileSystem();                  // ﾌｫﾙﾀﾞが属するﾌｧｲﾙｼｽﾃﾑを得る()
                final FileSystem fs = FileSystems.getDefault();                 // 7.4.4.0 (2021/06/30) 上記と同じｵﾌﾞｼﾞｪｸﾄだから。

                // try-with-resources 文 (AutoCloseable)
                // ﾌｧｲﾙｼｽﾃﾑに対応する監視ｻｰﾋﾞｽを構築する.
                // (一つのｻｰﾋﾞｽで複数の監視が可能)
                try( WatchService watcher = fs.newWatchService() ) {
                        // ﾌｫﾙﾀﾞに対して監視ｻｰﾋﾞｽを登録する.
                        final WatchKey watchKey = dirPath.register( watcher , weKind , extModifiers );

                        // 監視が有効であるかぎり、ﾙｰﾌﾟする.
                        // (監視がcancelされるか、監視ｻｰﾋﾞｽが停止した場合はfalseとなる)
                        try {
                                boolean flag = true;
                                while( flag && running ) {                                                                              // 7.4.4.0 (2021/06/30) 復活
//                              while( flag && running.get() ) {                                                                // 7.2.9.4 (2020/11/20)
                                        // ｽﾚｯﾄﾞの割り込み = 終了要求を判定する.
                        //              if( Thread.currentThread().isInterrupted() ) {
                        //                      throw new InterruptedException();
                        //              }

                                        // take は、ﾌｧｲﾙ変更ｲﾍﾞﾝﾄが発生するまで待機する.
                                        final WatchKey detectKey = watcher.take();                      // poll() は、ｷｭｰが空の場合はﾌﾞﾛｯｸせずに null を返す

                                        // ｲﾍﾞﾝﾄ発生元を判定する
//                                      if( detectKey.equals( watchKey ) ) {
                                        if( watchKey.equals( detectKey ) ) {                            // 8.0.0.0 (2021/07/01) 入れ替え(null対応)
                                                // 発生したｲﾍﾞﾝﾄ内容をﾌﾟﾘﾝﾄする.
                                                for( final WatchEvent<?> event : detectKey.pollEvents() ) {
                                                        // 追加・変更・削除対象のﾌｧｲﾙを取得する.
                                                        // (ただし、overflow時などはnullとなることに注意)
                                                        final Path path = (Path)event.context();
                                                        if( path != null && pathMchSet.matches( path ) ) {
                                                                final Path fpath = dirPath.resolve( path );
                                                                synchronized( dirPath ) {                               // 8.0.0.0 (2021/07/01) dirPathのsynchronized作成
                                                                        // 8.5.4.2 (2024/01/12) PMD 7.0.0 LinguisticNaming
//                                                                      if( dWatch == null || dWatch.setAdd( fpath) ) {         // このｾｯﾄ内に、指定された要素がなかった場合はtrue
                                                                        if( dWatch == null || dWatch.pathSetAdd( fpath) ) {     // このｾｯﾄ内に、指定された要素がなかった場合はtrue
                                                                                action.accept( event.kind().name() , fpath );
                                                                        }
                                                                        else {
                                                                                // CREATE と MODIFY などのｲﾍﾞﾝﾄが連続して発生するｹｰｽへの対応
                                                                                LOGGER.info( () -> "WatchEvent Duplication: " + fpath );
                                                                        }
                                                                }
                                                        }
                                                }
                                        }

                                        // ｲﾍﾞﾝﾄの受付を再開する.
                                        if( detectKey != null ) {               // 8.0.0.0 (2021/07/01) null対応
                                                detectKey.reset();
                                        }

                                        if( dWatch != null ) {
                                                dWatch.setClear();                      // Path重複ﾁｪｯｸ用のSetは、一連のｲﾍﾞﾝﾄ完了時にｸﾘｱしておきます。
                                        }

                                        // 監視ｻｰﾋﾞｽが活きている、または、ｽﾚｯﾄﾞの割り込み( = 終了要求)がないことを、をﾁｪｯｸする。
                                        flag = watchKey.isValid() && !Thread.currentThread().isInterrupted() ;

                                        // 7.4.4.0 (2021/06/30) ※ 63ﾌｫﾙﾀﾞ以上は、監視できない？(Tomcat上では？)
                                        if( !watchKey.isValid() ) {
                                                LOGGER.warning( () -> "FileWatch No isValid : [" + dirPath + "]" );
                                        }
                                }
                        }
                        catch( final InterruptedException ex ) {
//                              LOGGER.warning( () -> "【WARNING】 FileWatch Canceled:" + dirPath );
                                LOGGER.warning( () -> "FileWatch Canceled : [" + dirPath + "]" );
                        }
                        finally {
                                // ｽﾚｯﾄﾞの割り込み = 終了要求なので監視をｷｬﾝｾﾙしﾙｰﾌﾟを終了する。
                                if( watchKey != null ) {
                                        watchKey.cancel();
                                }
                        }
                }
                // FileSystemの実装(sun.nio.fs.WindowsFileSystem)は、close() 未ｻﾎﾟｰﾄ
                catch( final UnsupportedOperationException ex ) {
                        LOGGER.warning( () -> "FileSystem close : [" + dirPath + "]" );
                }

                // 7.4.4.0 (2021/06/30) 念のため、入れておきます。
                catch( final Throwable th ) {
                        // MSG0021 = 予期せぬｴﾗｰが発生しました。\n\tﾒｯｾｰｼﾞ=[{0}]
                        final String errMsg = "FileWatch#execute : Path=" + dirPath ;
                        LOGGER.warning( th , "MSG0021" , errMsg );
                }

//              LOGGER.info( () -> "FileWatch End: " + dirPath );
                LOGGER.info( () -> "FileWatch End : [" + dirPath + "]" );

//              thread  = null;                                 // 1.1.0 (2018/02/01) 停止処理
        //      isError = true;                                 // 何らかの原因で停止すれば、ｴﾗｰと判断します。
        }

        /**
         *このｵﾌﾞｼﾞｪｸﾄの文字列表現を返します。
         *
         * @return      このｵﾌﾞｼﾞｪｸﾄの文字列表現
         */
        @Override               // Object
        public String toString() {
                return getClass().getSimpleName() + ":" + dirPath + " , " + DIR_WATCH_EVENT + "=[" + useDirWatch + "]" ;
        }
}