//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Runtime.InteropServices;
//using System.Threading;
//using System.Diagnostics;
//using System.IO;
//using Wox.Infrastructure.MFTSearch;

//namespace MyEverything
//{
//    internal class VolumeMonitor
//    {

//        public Action<USNRecord> RecordAddedEvent;
//        public Action<USNRecord> RecordDeletedEvent;
//        public Action<USNRecord, USNRecord> RecordRenameEvent;

//        public void Monitor(List<string> volumes, MFTSearcherCache db)
//        {
//            foreach (var volume in volumes)
//            {
//                if (string.IsNullOrEmpty(volume)) throw new InvalidOperationException("Volume cant't be null or empty string.");
//                if (!db.ContainsVolume(volume)) throw new InvalidOperationException(string.Format("Volume {0} must be scaned first."));
//                Thread th = new Thread(new ParameterizedThreadStart(MonitorThread));
//                th.Start(new Dictionary<string, object> { { "Volume", volume }, { "MFTSearcherCache", db } });
//            }
//        }
//        private PInvokeWin32.READ_USN_JOURNAL_DATA SetupInputData4JournalRead(string volume, uint reason)
//        {
//            IntPtr pMonitorVolume = MFTSearcher.GetVolumeJournalHandle(volume);
//            uint bytesReturned = 0;
//            PInvokeWin32.USN_JOURNAL_DATA ujd = new PInvokeWin32.USN_JOURNAL_DATA();
//            Wox.Infrastructure.MFTSearch.MFTSearcher.QueryUSNJournal(pMonitorVolume, out ujd, out bytesReturned);

//            // 构建输入参数
//            PInvokeWin32.READ_USN_JOURNAL_DATA rujd = new PInvokeWin32.READ_USN_JOURNAL_DATA();
//            rujd.StartUsn = ujd.NextUsn;
//            rujd.ReasonMask = reason;
//            rujd.ReturnOnlyOnClose = 1;
//            rujd.Timeout = 0;
//            rujd.BytesToWaitFor = 1;
//            rujd.UsnJournalID = ujd.UsnJournalID;

//            return rujd;
//        }
//        private void MonitorThread(object param)
//        {

//            MFTSearcherCache db = (param as Dictionary<string, object>)["MFTSearcherCache"] as MFTSearcherCache;
//            string volume = (param as Dictionary<string, object>)["Volume"] as string;
//            IntPtr pbuffer = Marshal.AllocHGlobal(0x1000);
//            PInvokeWin32.READ_USN_JOURNAL_DATA rujd = SetupInputData4JournalRead(volume, 0xFFFFFFFF);
//            UInt32 cbRead;
//            IntPtr prujd;

//            while (true)
//            {
//                prujd = Marshal.AllocHGlobal(Marshal.SizeOf(rujd));
//                PInvokeWin32.ZeroMemory(prujd, Marshal.SizeOf(rujd));
//                Marshal.StructureToPtr(rujd, prujd, true);

//                Debug.WriteLine(string.Format("\nMoniting on {0}......", volume));
//                IntPtr pVolume = Wox.Infrastructure.MFTSearch.MFTSearcher.GetVolumeJournalHandle(volume);

//                bool fok = PInvokeWin32.DeviceIoControl(pVolume,
//                    PInvokeWin32.FSCTL_READ_USN_JOURNAL,
//                    prujd, Marshal.SizeOf(typeof(PInvokeWin32.READ_USN_JOURNAL_DATA)),
//                    pbuffer, 0x1000, out cbRead, IntPtr.Zero);

//                IntPtr pRealData = new IntPtr(pbuffer.ToInt32() + Marshal.SizeOf(typeof(Int64)));
//                uint offset = 0;

//                if (fok)
//                {
//                    while (offset + Marshal.SizeOf(typeof(Int64)) < cbRead)
//                    {
//                        PInvokeWin32.USN_RECORD usn = new PInvokeWin32.USN_RECORD(new IntPtr(pRealData.ToInt32() + (int)offset));
//                        ProcessUSN(usn, volume, db);
//                        offset += usn.RecordLength;
//                    }
//                }

//                Marshal.FreeHGlobal(prujd);
//                rujd.StartUsn = Marshal.ReadInt64(pbuffer);
//            }
//        }
//        private void ProcessUSN(PInvokeWin32.USN_RECORD usn, string volume, MFTSearcherCache db)
//        {
//            var dbCached = db.FindByFrn(volume, usn.FRN);
//            Wox.Infrastructure.MFTSearch.MFTSearcher.FillPath(volume, dbCached, db);
//            Debug.WriteLine(string.Format("------USN[frn={0}]------", usn.FRN));
//            Debug.WriteLine(string.Format("FileName={0}, USNChangeReason={1}", usn.FileName, USNChangeReason.ReasonPrettyFormat(usn.Reason)));
//            Debug.WriteLine(string.Format("FileName[Cached]={0}", dbCached == null ? "NoCache" : dbCached.FullPath));
//            Debug.WriteLine("--------------------------------------");

//            if (MaskEqual(usn.Reason, USNChangeReason.USN_REASONS["USN_REASON_RENAME_NEW_NAME"]))
//                ProcessRenameNewName(usn, volume, db);
//            if ((usn.Reason & USNChangeReason.USN_REASONS["USN_REASON_FILE_CREATE"]) != 0)
//                ProcessFileCreate(usn, volume, db);
//            if (MaskEqual(usn.Reason, USNChangeReason.USN_REASONS["USN_REASON_FILE_DELETE"]))
//                ProcessFileDelete(usn, volume, db);
//        }
//        private void ProcessFileDelete(PInvokeWin32.USN_RECORD usn, string volume, MFTSearcherCache db)
//        {
//            var cached = db.FindByFrn(volume, usn.FRN);
//            if (cached == null)
//            {
//                return;
//            }
//            else
//            {
//                Wox.Infrastructure.MFTSearch.MFTSearcher.FillPath(volume, cached, db);
//                var deleteok = db.DeleteRecord(volume, usn.FRN);
//                Debug.WriteLine(string.Format(">>>> File {0} deleted {1}.", cached.FullPath, deleteok ? "successful" : "fail"));
//                if (RecordDeletedEvent != null)
//                    RecordDeletedEvent(cached);
//            }
//        }
//        private void ProcessRenameNewName(PInvokeWin32.USN_RECORD usn, string volume, MFTSearcherCache db)
//        {
//            USNRecord newRecord = USNRecord.ParseUSN(volume, usn);
//            //string fullpath = newRecord.Name;
//            //db.FindRecordPath(newRecord, ref fullpath, db.GetFolderSource(volume));
//            //newRecord.FullPath = fullpath;
//            var oldRecord = db.FindByFrn(volume, usn.FRN);
//            Wox.Infrastructure.MFTSearch.MFTSearcher.FillPath(volume, oldRecord, db);
//            Wox.Infrastructure.MFTSearch.MFTSearcher.FillPath(volume, newRecord, db);
//            Debug.WriteLine(string.Format(">>>> RenameFile {0} to {1}", oldRecord.FullPath, newRecord.FullPath));
//            db.UpdateRecord(volume, newRecord,
//                usn.IsFolder ? USNRecordType.Folder : USNRecordType.File);
//            if (RecordRenameEvent != null) RecordRenameEvent(oldRecord, newRecord);
//            if (newRecord.FullPath.Contains("$RECYCLE.BIN"))
//            {
//                Debug.WriteLine(string.Format(">>>> Means {0} moved to recycle.", oldRecord.FullPath));
//            }
//        }
//        private void ProcessFileCreate(PInvokeWin32.USN_RECORD usn, string volume, MFTSearcherCache db)
//        {
//            USNRecord record = USNRecord.ParseUSN(volume, usn);
//            //string fullpath = record.Name;
//            //db.FindRecordPath(record, ref fullpath, db.GetFolderSource(volume));
//            //record.FullPath = fullpath;
//            db.AddRecord(volume, record, usn.IsFolder ? USNRecordType.Folder : USNRecordType.File);
//            Wox.Infrastructure.MFTSearch.MFTSearcher.FillPath(volume, record, db);
//            Debug.WriteLine(string.Format(">>>> NewFile: {0}", record.FullPath));
//            if (RecordAddedEvent != null)
//                RecordAddedEvent(record);
//        }


//        private bool MaskEqual(uint target, uint compare)
//        {
//            return (target & compare) != 0;
//        }
//    }
//}