using Microsoft.Win32;

using pEp.UI;

using pEpCOMServerAdapterLib;

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Globalization;

using System.IO;

using System.Runtime.InteropServices;

using System.Threading;

using System.Windows.Forms;

using Office = Microsoft.Office.Core;

using Outlook = Microsoft.Office.Interop.Outlook;

namespace pEp

{

    public partial class ThisAddIn

    {

        #region VSTO generated code

        /// <summary>

        /// Required method for Designer support - do not modify

        /// the contents of this method with the code editor.

        /// </summary>

        private void InternalStartup()

        {

            this.Startup += new System.EventHandler(ThisAddIn_Startup);

            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);

        }

        #endregion

        internal delegate void NewAccountEventHandler(object sender, NewAccountEventArgs e);

        /// <summary>

        /// Custom event for when the add-in is starting for the first time.

        /// </summary>

        internal event EventHandler FirstStartup;

        /// <summary>

        /// Custom event for when a new account is detected by the add-in.

        /// </summary>

        internal event NewAccountEventHandler NewAccount;

        private List<KeyValuePair<CultureInfo, string>> _LanguageList       = null;

        private static pEpEngine                        _PEPEngine          = null;

        private Outlook.Folder                          _PEPStoreRootFolder = null;

        private PEPSettings                             _Settings           = null;

#if !READER_RELEASE_MODE

        private AdapterCallbacks adapterCallbacks = null;

#endif

        private bool                       initialized               = false;

        private bool                       isItemSendHandlerEnabled  = true;

        private FormControlOptions.State   lastOptionsState          = null;

        private Dictionary<string, string> userIdCache               = new Dictionary<string, string>();

        private List<WatchedSentFolder>    watchedSentFolders        = new List<WatchedSentFolder>();

        private List<WatchedMailItem>      watchedMailItems          = new List<WatchedMailItem>();

        /**************************************************************

         * 

         * Property Accessors

         * 

         *************************************************************/

        /// <summary>

        /// Gets the list of languages supported in the pEp engine.

        /// The list of language includes a key-value pair of the culture as well as a 

        /// display phrase in the native language for the trustwords.

        /// (phrase example: "I want to display the trustwords in English language")

        /// </summary>

        internal List<KeyValuePair<CultureInfo, string>> LanguageList

        {

            get

            {

                string code;

                string phrase;

                string engineList;

                string[] languages;

                string[] language;

                if (this._LanguageList == null)

                {

                    this._LanguageList = new List<KeyValuePair<CultureInfo, string>>();

                    try

                    {

                        engineList = ThisAddIn.PEPEngine.GetLanguageList();

                    }

                    catch

                    {

                        engineList = "";

                        Log.Error("LanguageList: Failed to get list from engine.");

                    }

                    languages = engineList.Split('\n');

                    // Go through each language group

                    for (int i = 0; i < languages.Length; i++)

                    {

                        language = languages[i].Split(',');

                        if (language.Length == 3)

                        {

                            code = language[0].Trim();

                            code = code.Replace("\"", "");

                            phrase = language[2].Trim();

                            phrase = phrase.Replace("\"", "");

                            this._LanguageList.Add(new KeyValuePair<CultureInfo, string>(new CultureInfo(code),

                                                                                         phrase));

                        }

                    }

                }

                return (this._LanguageList);

            }

        }

        /// <summary>

        /// Gets the static pEp engine reference.

        /// </summary>

        internal static pEpEngine PEPEngine

        {

            get

            {

                if (ThisAddIn._PEPEngine == null)

                {

                    try

                    {

                        ThisAddIn._PEPEngine = new pEpEngine();

                    }

                    catch (Exception ex)

                    {

                        string summaryMessage = Properties.Resources.Message_InitError + " " +

                                                Properties.Resources.Message_Reinstall;

                        Globals.StopAndSendCrashReport(ex, summaryMessage, false, true);

                        return (null);

                    }

                }

                return (ThisAddIn._PEPEngine);

            }

        }

        /// <summary>

        /// Gets the root folder of the pEp data store.

        /// This is primarily used to save unencrypted outlook mail items (mirrors).

        /// </summary>

        internal Outlook.Folder PEPStoreRootFolder

        {

            get { return (this._PEPStoreRootFolder); }

        }

        /// <summary>

        /// Gets the current pEp settings for the add-in.

        /// </summary>

        internal PEPSettings Settings

        {

            get { return (this._Settings); }

        }

        /**************************************************************

         * 

         * Methods

         * 

         *************************************************************/

        /// <summary>

        /// Required override to add ribbon extensions.

        /// </summary>

        protected override Microsoft.Office.Core.IRibbonExtensibility CreateRibbonExtensibilityObject()

        {

            return new RibbonCustomizations();

        }

        /// <summary>

        /// Syncronizes the current settings class with the pEp for Outlook instance and the pEp engine.

        /// This code should be similar to the Settings_PropertyChanged event.

        /// </summary>

        private void SyncWithSettings()

        {

            bool exists;

            Outlook.NameSpace ns = Application.Session;

            Outlook.Account acct = null;

            Outlook.Accounts accounts = ns.Accounts;

            List<KeyValuePair<CultureInfo, string>> languages;

            List<PEPSettings.PEPAccountSettings> legacyAcctSettings = new List<PEPSettings.PEPAccountSettings>();

            PEPSettings.PEPAccountSettings newAcctSettings;

            PEPSettings.PEPAccountSettings existingAcctSettings;

            try

            {

                if (this._Settings != null)

                {

                    // Extract any legacy account settings which don't have a Type but do have an SMTP address

                    for (int i = (this._Settings.AccountSettingsList.Count - 1); i >= 0; i--)

                    {

                        existingAcctSettings = this._Settings.AccountSettingsList[i];

                        if ((string.IsNullOrEmpty(existingAcctSettings.SmtpAddress) == false) &&

                            (string.IsNullOrEmpty(existingAcctSettings.Type) == true))

                        {

                            legacyAcctSettings.Add(existingAcctSettings);

                            this._Settings.AccountSettingsList.RemoveAt(i);

                        }

                    }

                    // Add any new Outlook accounts to the account settings list

                    for (int i = 1; i <= accounts.Count; i++)

                    {

                        acct = accounts[i];

                        if (string.IsNullOrWhiteSpace(acct.SmtpAddress) == false)

                        {

                            newAcctSettings = new PEPSettings.PEPAccountSettings();

                            newAcctSettings.SmtpAddress = acct.SmtpAddress;

                            newAcctSettings.Type = acct.AccountType.ToString();

                            // Check if it already exists in the list

                            existingAcctSettings = this._Settings.GetAccountSettings(newAcctSettings.SmtpAddress, newAcctSettings.Type);

                            if (existingAcctSettings == null)

                            {

                                this._Settings.AccountSettingsList.Add(newAcctSettings);

                            }

                        }

                        else

                        {

                            Log.Warning("SyncWithSettings: Invalid Smtp address detected, skipping account.");

                        }

                        Marshal.ReleaseComObject(acct);

                        acct = null;

                    }

                    // Remove any entries of the account settings list not in Outlook

                    // This is needed to skip any entries in the registry that may be invalid and user created

                    for (int i = (this._Settings.AccountSettingsList.Count - 1); i >= 0; i--)

                    {

                        existingAcctSettings = this._Settings.AccountSettingsList[i];

                        // Check if it exists in Outlook

                        exists = false;

                        for (int j = 1; j <= accounts.Count; j++)

                        {

                            acct = accounts[j];

                            newAcctSettings = new PEPSettings.PEPAccountSettings();

                            newAcctSettings.SmtpAddress = acct.SmtpAddress;

                            newAcctSettings.Type = acct.AccountType.ToString();

                            if (existingAcctSettings.EqualsByAddressAndType(newAcctSettings))

                            {

                                exists = true;

                            }

                            Marshal.ReleaseComObject(acct);

                            acct = null;

                            if (exists) { break; }

                        }

                        // Delete if necessary

                        if (exists == false)

                        {

                            this._Settings.AccountSettingsList.RemoveAt(i);

                        }

                    }

                    // Add and legacy settings back to the validated account settings list

                    for (int i = 0; i < legacyAcctSettings.Count; i++)

                    {

                        for (int j = 0; j < this._Settings.AccountSettingsList.Count; j++)

                        {

                            existingAcctSettings = this._Settings.AccountSettingsList[j];

                            if (legacyAcctSettings[i].EqualsByAddress(existingAcctSettings))

                            {

                                // Set the store securely setting only

                                existingAcctSettings.IsSecureStorageEnabled = legacyAcctSettings[i].IsSecureStorageEnabled;

                            }

                        }

                    }

                    // Sync IsKeyServerUsed with engine

                    if (this._Settings.IsKeyServerUsed)

                    {

                        ThisAddIn.PEPEngine.StartKeyserverLookup();

                    }

                    else

                    {

                        ThisAddIn.PEPEngine.StopKeyserverLookup();

                    }

                    // Sync IsPassiveModeEnabled with engine

                    ThisAddIn.PEPEngine.PassiveMode(this._Settings.IsPassiveModeEnabled);

                    // Sync IsPEPFolderVisible with Outlook

                    this.SetPEPStoreRootFolderVisibility(this._Settings.IsPEPFolderVisible);

                    // Sync IsUnencryptedSubjectEnabled with engine

                    ThisAddIn.PEPEngine.UnencryptedSubject(this._Settings.IsUnencryptedSubjectEnabled);

                    // Sync IsVerboseLoggingEnabled with engine

                    ThisAddIn.PEPEngine.VerboseLogging(this._Settings.IsVerboseLoggingEnabled);

                    // Sync TrustwordsCulture with engine

                    if (this._Settings.TrustwordsCulture != null)

                    {

                        // Validate it exists in the engine list

                        exists = false;

                        languages = this.LanguageList;

                        foreach (KeyValuePair<CultureInfo, string> entry in languages)

                        {

                            if (entry.Key.LCID == this._Settings.TrustwordsCulture.LCID)

                            {

                                exists = true;

                                break;

                            }

                        }

                        if (exists == false)

                        {

                            // Reset to default

                            this._Settings.TrustwordsCulture = this.GetActiveUICulture();

                            Log.Warning("SyncWithSettings: Invalid TrustwordsCulture detected, setting to default.");

                        }

                    }

                    else

                    {

                        // Reset to default

                        this._Settings.TrustwordsCulture = this.GetActiveUICulture();

                    }

                }

            }

            catch { }

            finally

            {

                if (ns != null)

                {

                    Marshal.ReleaseComObject(ns);

                    ns = null;

                }

                if (acct != null)

                {

                    Marshal.ReleaseComObject(acct);

                    acct = null;

                }

                if (accounts != null)

                {

                    Marshal.ReleaseComObject(accounts);

                    accounts = null;

                }

            }

            return;

        }

        /// <summary>

        /// Compares the given settings with the current state of Outlook and detects any changes.

        /// This is primarily used to find new accounts or identify first startup.

        /// </summary>

        /// <param name="lastSettings">The last settings to compare with. 

        /// This should be the settings just loaded from the registry at startup (last saved settings).</param>

        private void DetectChangesFromLastSettings(PEPSettings lastSettings)

        {

            Outlook.Account account = null;

            Outlook.Accounts accounts = null;

            Outlook.NameSpace ns = null;

            PEPSettings.PEPAccountSettings acctSettings;

            NewAccountEventArgs args;

            // Detect first startup

            if (lastSettings.IsFirstStartupComplete == false)

            {

                this.FirstStartup?.Invoke(this, new EventArgs());

            }

            // Detect new accounts

            try

            {

                ns = this.Application.Session;

                accounts = ns.Accounts;

                for (int i = 1; i <= accounts.Count; i++)

                {

                    account = accounts[i];

                    if (account != null)

                    {

                        // Locate any existing account settings

                        acctSettings = Globals.ThisAddIn.Settings.GetAccountSettings(account.SmtpAddress,

                                                                                     account.AccountType.ToString());

                        if (acctSettings == null)

                        {

                            // Raise the event

                            args = new NewAccountEventArgs();

                            args.AccountType = account.AccountType;

                            args.DisplayName = account.DisplayName;

                            args.SmtpAddress = account.SmtpAddress;

                            args.UserName = account.UserName;

                            this.NewAccount?.Invoke(this, args);

                        }

                        Marshal.ReleaseComObject(account);

                        account = null;

                    }

                }

            }

            catch (Exception ex)

            {

                Log.Error("DetectChangesFromLastSettings: Failure detecting new accounts, " + ex.ToString());

            }

            finally

            {

                if (account != null)

                {

                    Marshal.ReleaseComObject(account);

                    account = null;

                }

                if (accounts != null)

                {

                    Marshal.ReleaseComObject(accounts);

                    accounts = null;

                }

                if (ns != null)

                {

                    Marshal.ReleaseComObject(ns);

                    ns = null;

                }

            }

            return;

        }

        /// <summary>

        /// Detects and disables GPG for Windows GpgOL Outlook add-in.

        /// </summary>

        /// <returns>True if the GpgOL add-in was disabled.</returns>

        private bool DisableGpgOL()

        {

            bool wasDisabled = false;

            Office.COMAddIns comAddIns = null;

            try

            {

                comAddIns = Globals.ThisAddIn.Application.COMAddIns;

                foreach (Office.COMAddIn addin in comAddIns)

                {

                    if (string.Equals(addin.Description, "GpgOL - The GnuPG Outlook Plugin", StringComparison.OrdinalIgnoreCase))

                    {

                        addin.Connect = false;

                        wasDisabled = true;

                        Log.Info("DisableGpgOL: GpgOL was detected and disabled.");

                    }

                }

            }

            catch (Exception ex)

            {

                Log.Error("DisableGpgOL: Error trying to disable GpgOL, " + ex.ToString());

            }

            finally

            {

                if (comAddIns != null)

                {

                    Marshal.ReleaseComObject(comAddIns);

                    comAddIns = null;

                }

            }

            return (wasDisabled);

        }

        /// <summary>

        /// Registers each personal identity in the pEp engine.

        /// An identity is determined by each account in Outlook.

        /// </summary>

        internal void RegisterMyself()

        {

            Outlook.NameSpace ns = this.Application.Session;

            Outlook.Account acct = null;