using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.IO;
using System.Text.Json;
using System.Windows.Forms;
using Outlook = Microsoft.Office.Interop.Outlook;

namespace OutlookCaseHelper
{
    public class OutlookHelper
    {
        private Outlook.Application outlookApp;
        private Outlook.NameSpace outlookNamespace;
        private HashSet<string> activeRules = new HashSet<string>();
        private readonly string rulesFilePath;

        public OutlookHelper()
        {
            outlookApp = new Outlook.Application();
            outlookNamespace = outlookApp.GetNamespace("MAPI");
            rulesFilePath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                "OutlookCaseHelper",
                "active_rules.json");
            Directory.CreateDirectory(Path.GetDirectoryName(rulesFilePath)!);
            LoadRules();
        }

        private void LoadRules()
        {
            try
            {
                if (File.Exists(rulesFilePath))
                {
                    var json = File.ReadAllText(rulesFilePath);
                    var rules = JsonSerializer.Deserialize<List<string>>(json);
                    if (rules != null)
                        activeRules = new HashSet<string>(rules);
                }
            }
            catch { }
        }

        private void SaveRules()
        {
            try
            {
                var json = JsonSerializer.Serialize(new List<string>(activeRules));
                File.WriteAllText(rulesFilePath, json);
            }
            catch { }
        }

        public HashSet<string> GetActiveRules() => activeRules;

        public string? GetSelectedEmailTrackingId()
        {
            try
            {
                Outlook.Explorer activeExplorer = outlookApp.ActiveExplorer();
                if (activeExplorer == null) return null;

                Outlook.Selection selection = activeExplorer.Selection;
                if (selection.Count == 0) return null;

                Outlook.MailItem? email = selection[1] as Outlook.MailItem;
                if (email == null) return null;

                Match match = Regex.Match(email.Subject, @"TrackingID#(\d+)");
                if (match.Success)
                    return match.Groups[1].Value;

                return null;
            }
            catch { return null; }
        }

        public bool CreateFolderAndMoveEmails(string trackingId)
        {
            try
            {
                Outlook.Folder? inboxFolder =
                    outlookNamespace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox) as Outlook.Folder;
                if (inboxFolder == null)
                {
                    MessageBox.Show("Inbox folder is null", "Debug");
                    return false;
                }

                Outlook.Folder casesFolder = GetOrCreateFolder(inboxFolder, "Cases");
                Outlook.Folder activeFolder = GetOrCreateFolder(casesFolder, "Active");
                Outlook.Folder trackingFolder = GetOrCreateFolder(activeFolder, trackingId);

                MoveEmailsWithTrackingId(inboxFolder, trackingId, trackingFolder);

                Outlook.Folder? sentFolder =
                    outlookNamespace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderSentMail) as Outlook.Folder;
                if (sentFolder != null)
                    MoveEmailsWithTrackingId(sentFolder, trackingId, trackingFolder);

                activeRules.Add(trackingId);
                SaveRules();

                MessageBox.Show($"Rules file: {rulesFilePath}\nRules count: {activeRules.Count}", "Debug");

                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error in CreateFolderAndMoveEmails:\n{ex.Message}\n\n{ex.StackTrace}", "Debug Error");
                return false;
            }
        }

        public bool RemoveRuleAndMoveToClosed(string trackingId)
        {
            try
            {
                Outlook.Folder? inboxFolder =
                    outlookNamespace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox) as Outlook.Folder;
                if (inboxFolder == null) return false;

                Outlook.Folder? casesFolder = GetFolder(inboxFolder, "Cases");
                if (casesFolder == null) return false;

                Outlook.Folder? activeFolder = GetFolder(casesFolder, "Active");
                if (activeFolder == null) return false;

                Outlook.Folder? trackingFolder = GetFolder(activeFolder, trackingId);
                if (trackingFolder == null) return false;

                Outlook.Folder closedFolder = GetOrCreateFolder(casesFolder, "Closed");
                trackingFolder.MoveTo(closedFolder);

                activeRules.Remove(trackingId);
                SaveRules();

                return true;
            }
            catch { return false; }
        }

        public void ProcessActiveRules()
        {
            if (activeRules.Count == 0) return;

            try
            {
                Outlook.Folder? inboxFolder =
                    outlookNamespace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox) as Outlook.Folder;
                if (inboxFolder == null) return;

                Outlook.Folder? sentFolder =
                    outlookNamespace.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderSentMail) as Outlook.Folder;

                Outlook.Folder casesFolder = GetOrCreateFolder(inboxFolder, "Cases");
                Outlook.Folder activeFolder = GetOrCreateFolder(casesFolder, "Active");

                foreach (var trackingId in activeRules)
                {
                    Outlook.Folder trackingFolder = GetOrCreateFolder(activeFolder, trackingId);
                    MoveEmailsWithTrackingId(inboxFolder, trackingId, trackingFolder);
                    if (sentFolder != null)
                        MoveEmailsWithTrackingId(sentFolder, trackingId, trackingFolder);
                }
            }
            catch { }
        }

        private Outlook.Folder GetOrCreateFolder(Outlook.Folder parent, string name)
        {
            foreach (Outlook.Folder folder in parent.Folders)
            {
                if (folder.Name == name)
                    return folder;
            }
            return (Outlook.Folder)parent.Folders.Add(name);
        }

        private Outlook.Folder? GetFolder(Outlook.Folder parent, string name)
        {
            foreach (Outlook.Folder folder in parent.Folders)
            {
                if (folder.Name == name)
                    return folder;
            }
            return null;
        }

        private void MoveEmailsWithTrackingId(Outlook.Folder source, string trackingId, Outlook.Folder dest)
        {
            var toMove = new List<Outlook.MailItem>();

            foreach (object item in source.Items)
            {
                Outlook.MailItem? mail = item as Outlook.MailItem;
                if (mail != null && mail.Subject != null && mail.Subject.Contains($"TrackingID#{trackingId}"))
                    toMove.Add(mail);
            }

            foreach (var mail in toMove)
                mail.Move(dest);
        }
    }
}