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..

        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;

            ProfileComboBox.SelectedIndex = 0;
        }

        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();

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

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

        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);
                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 };

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

                node.Nodes.Add(fileNode);
                node.ForeColor = fileNode.ForeColor;
            }

            return node;
        }

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

            RootFolderComboBox.Items.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 folder = FolderGroups[RootFolderComboBox.Text];
            //var db = new DB();
            //var pattern = db.GetNamingPatternById(folder.PatternId);
            //var regex = new Regex(pattern);
            //PrimaryFilesTreeView.Nodes.Clear();

            //var dirs = Directory.EnumerateDirectories(folder.Path);

            //foreach (var dir in dirs)
            //{
            //    var dirInfo = new DirectoryInfo(dir);
            //    PrimaryFilesTreeView.Nodes.Add(CreateNode(dirInfo, pattern));
            //}

            //foreach(var file in Directory.EnumerateFiles(folder.Path))
            //{
            //    var fileInfo = new FileInfo(file);
            //    var fileNode = new TreeNode(fileInfo.Name) { Name = fileInfo.FullName };

            //    if (!regex.IsMatch(fileInfo.Name))
            //    {
            //        fileNode.ForeColor = Color.DarkOrange;
            //    }

            //    PrimaryFilesTreeView.Nodes.Add(fileNode);
            //}

            WriteFilesToDb(folder.Path);
        }

        private TreeNode CreateNode(DirectoryInfo dir, string pattern)
        {
            var folder = FolderGroups[RootFolderComboBox.Text];
            var profile = Profiles[ProfileComboBox.Text];
            var namingViolation = false;
            var node = new TreeNode(dir.Name) { Name = dir.FullName };
            var regex = new Regex(pattern);
            var db = new DB();

            var files = Directory.EnumerateFiles(dir.FullName);

            foreach (var file in files)
            {
                var fileInfo = new FileInfo(file);
                var fileNode = new TreeNode(fileInfo.Name) { Name = fileInfo.FullName };
                //var match = regex.Match(fileInfo.Name);
                //var stringBuilder = new StringBuilder();

                //if (!match.Groups[1].Success)
                //    stringBuilder.Append($"Failed to match {regex.GroupNameFromNumber(1)} ");//match.Groups[0].Name}");
                //if (!match.Groups[2].Success)
                //    stringBuilder.Append($"Failed to match {regex.GroupNameFromNumber(2)} ");

                if (!regex.IsMatch(fileInfo.Name))
                {
                    namingViolation = true;
                    fileNode.ForeColor = Color.DarkOrange;
                }

                node.Nodes.Add(fileNode);
                db.InsertNewFileRecord(GetFileSnapshots(dir.FullName), profile.Id, folder.Id, folder.Path);
            }

            if (namingViolation) node.ForeColor = Color.DarkOrange;

            var dirs = Directory.EnumerateDirectories(dir.FullName);

            foreach(var f in dirs)
            {
                var child = CreateNode(new DirectoryInfo(f), pattern);
                node.ForeColor = child.ForeColor;
                node.Nodes.Add(child);
            }

            return node;
        }

        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 = GetCurrentProfile();
            var folderGroup = GetCurrentFolderGroup();

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

            foreach(var file in dir.EnumerateFiles())
            {
                snapshots.Add(new DB.FileSnapshot
                {
                    FullPath = 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 GetCurrentProfile()
        {
            return Profiles[ProfileComboBox.Text];
        }

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

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