using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace DataOrganizer
{
    public partial class FileViewer : Form
    {
        private Dictionary<string, DB.Profile> Profiles { get; } = new Dictionary<string, DB.Profile>();
        private Dictionary<string, DB.FolderGroup> FolderGroups { get; } = new Dictionary<string, DB.FolderGroup>();
        private string CurrentNamingPattern { get; set; } = string.Empty;
        private ContextMenu PrimaryTreeContextMenu { get; set; } = new ContextMenu(); //Copy to default new content location, set new naming rules etc..
        private Snapshot ActiveSnapshotForPrimaryTree { get; set; }
        private Dictionary<string, TreeNode> PrimaryTreeNodes { get; set; } = new Dictionary<string, TreeNode>();

        public FileViewer()
        {
            InitializeComponent();
            var db = new DB();

            var profiles = db.GetProfiles();

            foreach(var profile in profiles)
            {
                ProfileComboBox.Items.Add(profile.Name);
                Profiles.Add(profile.Name, profile);
            }

            ProfileComboBox.SelectedIndexChanged += ProfileComboBox_SelectedIndexChanged;
            RootFolderComboBox.SelectedIndexChanged += SelectedFolderComboBox_SelectedIndexChanged;
            PrimaryFilesTreeView.NodeMouseClick += PrimaryFilesTreeView_NodeMouseClick;

            ProfileComboBox.SelectedIndex = 0;
        }

        private void PrimaryFilesTreeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
            if(ActiveSnapshotForPrimaryTree.Files.ContainsKey(e.Node.Name))
            {
                var file = ActiveSnapshotForPrimaryTree.Files[e.Node.Name];

                FileDetailsNameLabel.Text = $"Name: {file.Name}";
                FileDetailsFullPathLabel.Text = $"Full Path: {file.PathNoRoot}";
            }
        }

        private void SelectedFolderComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            var db = new DB();

            var folderGroup = FolderGroups[RootFolderComboBox.Text];
            CurrentNamingPattern = db.GetNamingPatternById(folderGroup.PatternId);
            var profile = Profiles[ProfileComboBox.Text];

            PrimaryFilesTreeView.Nodes.Clear();
            PrimaryTreeNodes.Clear();

            var files = db.GetFilesForProfileByFolderGroup(profile.Id, folderGroup.Id);
            ActiveSnapshotForPrimaryTree = new Snapshot(files, profile, folderGroup);

            foreach(var folder in ActiveSnapshotForPrimaryTree.Root.Folders)
            {
                PrimaryFilesTreeView.Nodes.Add(GetNodeFromSnapshot(folder));
            }

            //var count = 1;

            //foreach(var file in ActiveSnapshotForPrimaryTree.FileDuplicates)
            //{
            //    PrimaryTreeNodes[file.Value.File.PathNoRoot].Text = $"{count} ) {file.Value.File.Name}";
            //    PrimaryTreeNodes[file.Value.Duplicates[0].PathNoRoot].Text = $"{count} ) {file.Value.Duplicates[0].Name}";

            //    count++;
            //}
        }

        private TreeNode GetNodeFromSnapshot(KeyValuePair<string, Folder> folder)
        {
            var node = new TreeNode(folder.Value.Name) { Name = folder.Key, ToolTipText = folder.Key };
            var regex = new Regex(CurrentNamingPattern);

            foreach(var f in folder.Value.Folders)
            {
                var folderNode = GetNodeFromSnapshot(f);
                //PrimaryTreeNodes.Add(f.Key, folderNode);
                node.Nodes.Add(folderNode);
                if (folderNode.ForeColor == Color.Orange)
                {
                    node.ForeColor = folderNode.ForeColor;
                    node.ToolTipText = "Naming violations found!";
                }
            }

            foreach(var file in folder.Value.Files)
            {
                var fileNode = new TreeNode(file.Value.Name) { Name = file.Key, ToolTipText = file.Key };
                //PrimaryTreeNodes.Add(file.Key, fileNode);

                if (!regex.IsMatch(file.Value.Name)) fileNode.ForeColor = Color.Orange;

                node.Nodes.Add(fileNode);
                if(node.ForeColor != Color.Orange) node.ForeColor = fileNode.ForeColor;
                PrimaryTreeNodes.Add(file.Key, fileNode);
            }

            PrimaryTreeNodes.Add(folder.Key, node);

            return node;
        }

        private void ProfileComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            var profile = Profiles[ProfileComboBox.Text];

            RootFolderComboBox.Items.Clear();
            PrimaryTreeNodes.Clear();
            FolderGroups.Clear();

            if (profile.FolderGroups.Count > 0)
            {
                foreach (var folder in profile.FolderGroups)
                {
                    RootFolderComboBox.Items.Add(folder.Name);
                    FolderGroups.Add(folder.Name, folder);
                }

                RootFolderComboBox.SelectedIndex = 0;
            }

            RootFolderComboBox.Enabled = true;
        }

        private void FolderSelectButton_Click(object sender, EventArgs e)
        {
            //var folder = FolderGroups[RootFolderComboBox.Text];
            //var profile = Profiles[ProfileComboBox.Text];
            //var db = new DB();

            //StatusLabel.Text = $"{db.GetNamingPatternById(folder.PatternId)}";
            //StatusStrip.Refresh();

            //PrimaryFilesTreeView.Nodes.Clear();

            //var files = db.GetFilesForProfileByFolderGroup(profile.Id, folder.Id);

            //if (files.Count == 0) return;

            //var fileInfos = new List<FileInfo>();

            //foreach(var file in files)
            //{
            //    fileInfos.Add(new FileInfo(file.FullPath));
            //}
        }

        private void ScanRootFolderButton_Click(object sender, EventArgs e)
        {
            var folderGroup = GetActiveFolderGroup();
            var rootDepth = folderGroup.Path.Split(new char[] { Path.DirectorySeparatorChar }).Length;
            var newFiles = new List<FileInfo>();
            var rootFolder = new DirectoryInfo(folderGroup.Path);

            foreach (var dir in rootFolder.EnumerateDirectories()) newFiles.AddRange(ScanDirectory(dir));

            foreach (var file in rootFolder.EnumerateFiles())
            {
                if (!ActiveSnapshotForPrimaryTree.Files.ContainsKey(file.FullName))
                {
                    newFiles.Add(file);
                }
            }

            foreach (var newFile in newFiles)
            {
                var folders = newFile.DirectoryName.Split(new char[] { Path.DirectorySeparatorChar });
                var currentPath = folderGroup.Path;

                for(var i = rootDepth; i < folders.Length; i++)
                {
                    var previousPath = currentPath;
                    currentPath = Path.Combine(currentPath, folders[i]);

                    if(!PrimaryTreeNodes.ContainsKey(currentPath))
                    {
                        var node = new TreeNode(folders[i]) { ForeColor = Color.Blue, ToolTipText = currentPath };
                        PrimaryTreeNodes[currentPath] = node;
                        if (previousPath == folderGroup.Path)
                        {
                            PrimaryFilesTreeView.Nodes.Add(node);
                        }
                        else
                        {
                            PrimaryTreeNodes[previousPath].Nodes.Add(node);
                        }
                    }
                }

                PrimaryTreeNodes[currentPath].Nodes.Add(new TreeNode(newFile.Name) { ForeColor = Color.Blue });
            }
        }

        private List<FileInfo> ScanDirectory(DirectoryInfo dir)
        {
            var newFiles = new List<FileInfo>();

            foreach (var d in dir.EnumerateDirectories()) 
            {
                UpdateStatusStrip($"Processing {d.FullName}");
                newFiles.AddRange(ScanDirectory(d));
            }

            foreach(var file in dir.EnumerateFiles())
            {
                if (!ActiveSnapshotForPrimaryTree.Files.ContainsKey(file.FullName))
                {
                    newFiles.Add(file);
                }
                else
                {
                    //TODO: check for modifications
                }
            }

            foreach(var file in ActiveSnapshotForPrimaryTree.Files)
            {
                UpdateStatusStrip($"Checking for the existance of {file.Value.Name}");

                if(File.Exists(file.Key))
                {
                    //TODO: mark this file as deleted. Also scan the folders.
                }
            }

            return newFiles;
        }
        private void WriteFilesToDb(string root)
        {
            var dir = new DirectoryInfo(root);
            var folder = FolderGroups[RootFolderComboBox.Text];
            var profile = Profiles[ProfileComboBox.Text];
            //var db = new DB();
            //var pattern = db.GetNamingPatternById(folder.PatternId);

            WriteFilesInFolderToDb(dir.FullName, profile.Id, folder.Id, root);
            UpdateStatusStrip("Finished processing files.");
        }

        private void WriteFilesInFolderToDb(string path, int profileId, int folderId, string root)
        {
            var dir = new DirectoryInfo(path);
            var db = new DB();

            var files = GetFileSnapshots(dir.FullName);

            if(files.Count > 0 ) db.InsertNewFileRecord(files, profileId, folderId, root);

            foreach(var d in dir.EnumerateDirectories())
            {
                UpdateStatusStrip($"Processing {d.FullName}");

                WriteFilesInFolderToDb(d.FullName, profileId, folderId, root);
            }
        }

        private List<DB.FileSnapshot> GetFileSnapshots(string path)
        {
            var dir = new DirectoryInfo(path);
            var profile = GetActiveProfile();
            var folderGroup = GetActiveFolderGroup();

            var snapshots = new List<DB.FileSnapshot>();

            foreach(var file in dir.EnumerateFiles())
            {
                snapshots.Add(new DB.FileSnapshot
                {
                    PathNoRoot = file.FullName,
                    Name = file.Name,
                    CreationDate = file.CreationTimeUtc,
                    ModifiedDate = file.LastWriteTimeUtc,
                    ProfileId = profile.Id,
                    RootFolderId = folderGroup.Id,
                    Size = file.Length,
                    PatternId = 0 //TODO: Add something that let's the user override the global pattern.
                });
            }

            return snapshots;
        }

        private DB.Profile GetActiveProfile()
        {
            return Profiles[ProfileComboBox.Text];
        }

        private DB.FolderGroup GetActiveFolderGroup()
        {
            return FolderGroups[RootFolderComboBox.Text];
        }

        private void UpdateStatusStrip(string message)
        {
            StatusLabel.Text = message;
            StatusStrip.Refresh();
        }
    }
}