// VsPkg.cs : Implementation of P4Vs
//

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
using DevDriven.P4Vs.Common;
using DevDriven.P4Vs.External;
using EnvDTE;
using EnvDTE80;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
using Constants=EnvDTE.Constants;

namespace DevDriven.P4Vs
{
    /// <summary>
    /// This is the class that implements the package exposed by this assembly.
    ///
    /// The minimum requirement for a class to be considered a valid package for Visual Studio
    /// is to implement the IVsPackage interface and register itself with the shell.
    /// This package uses the helper classes defined inside the Managed Package Framework (MPF)
    /// to do it: it derives from the Package class that provides the implementation of the 
    /// IVsPackage interface and uses the registration attributes defined in the framework to 
    /// register itself and its components with the shell.
    /// </summary>
    // This attribute tells the registration utility (regpkg.exe) that this class needs
    // to be registered as package.
    [PackageRegistration(UseManagedResourcesOnly = true)]
    // A Visual Studio component can be registered under different regitry roots; for instance
    // when you debug your package you want to register it in the experimental hive. This
    // attribute specifies the registry root to use if no one is provided to regpkg.exe with
    // the /root switch.
    [DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\9.0")]
    // This attribute is used to register the informations needed to show the this package
    // in the Help/About dialog of Visual Studio.
    [InstalledProductRegistration(false, "#110", "#112", "1.0", IconResourceID = 400)]
    // In order be loaded inside Visual Studio in a machine that has not the VS SDK installed, 
    // package needs to have a valid load key (it can be requested at 
    // http://msdn.microsoft.com/vstudio/extend/). This attributes tells the shell that this 
    // package has a load key embedded in its resources.
    [ProvideLoadKey("Standard", "9.0", "P4Vs", "devDriven", 104)]
    // This attribute is needed to let the shell know that this package exposes some menus.
    [ProvideMenuResource(1000, 1)]
    [ProvideAutoLoad("{f1536ef8-92ec-443c-9ed7-fdadf150da82}")]
    [Guid(GuidList.guidP4VsPkgString)]
    public sealed class P4VsPackage : Package, IVsRunningDocTableEvents3, IVsTrackProjectDocumentsEvents2
    {
        private IVsRunningDocumentTable docTable;
        private readonly Guid outputPaneGuid = new Guid("{D79A528E-656F-432e-BAD8-C5A360A90699}");
        private readonly Guid errorPaneGuid = new Guid("{F661E4F6-2317-448a-A792-291F7EE4DFF5}");
        private IVsOutputWindowPane outputPane;
        private MultiLogger logger;
        private CommandExec exec;
        private PerforceCmds wrapper;
        private uint docTableCookie;
        private IVsTrackProjectDocuments2 trackDocs;
        private uint trackDocsCookie;
        private DTE2 dte;
        private Events2 events;
        private SolutionEvents solutionEvents;
        private ProjectItemsEvents projectEvents;
        private IVsOutputWindowPane errorPane;

        /// <summary>
        /// Default constructor of the package.
        /// Inside this method you can place any initialization code that does not require 
        /// any Visual Studio service because at this point the package object is created but 
        /// not sited yet inside Visual Studio environment. The place to do all the other 
        /// initialization is the Initialize method.
        /// </summary>
        public P4VsPackage()
        {
            Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering constructor for: {0}", ToString()));
        }


        /////////////////////////////////////////////////////////////////////////////
        // Overriden Package Implementation

        #region Package Members

        /// <summary>
        /// Initialization of the package; this method is called right after the package is sited, so this is the place
        /// where you can put all the initilaization code that rely on services provided by VisualStudio.
        /// </summary>
        protected override void Initialize()
        {
            Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, "Entering Initialize() of: {0}", ToString()));
            base.Initialize();

            IMenuCommandService mcs = GetService(typeof (IMenuCommandService)) as IMenuCommandService;
            if (null != mcs)
            {
                OleCommandHandlerGenerator.GenerateCommands(mcs, this);
            }
            errorPane = GetOutputPane(errorPaneGuid, "Perforce Errors");
            errorPane.Hide();
            outputPane = GetOutputPane(outputPaneGuid, "Perforce");
            OutputWindowLogger normallogger = new OutputWindowLogger(outputPane, 1, false);
            OutputWindowLogger errorlogger = new OutputWindowLogger(errorPane, 5, true);
            logger = new MultiLogger();
            logger.Add(normallogger);
            logger.Add(errorlogger);

            exec = new CommandExec(logger);
            wrapper = new PerforceCmds(exec, logger);

            trackDocs = (IVsTrackProjectDocuments2) GetService(typeof (SVsTrackProjectDocuments));
            trackDocs.AdviseTrackProjectDocumentsEvents(this, out trackDocsCookie);

            docTable = (IVsRunningDocumentTable) GetService(typeof (SVsRunningDocumentTable));
            docTable.AdviseRunningDocTableEvents(this, out docTableCookie);

            dte = (DTE2) GetService(typeof (DTE));
            events = (Events2) dte.Events;
            solutionEvents = events.SolutionEvents;
            solutionEvents.ProjectAdded += solutionEvents_ProjectAdded;
            projectEvents = events.ProjectItemsEvents;
            projectEvents.ItemAdded += projectEvents_ItemAdded;

            wrapper.CheckInstallation();
        }

        #endregion

        private void projectEvents_ItemAdded(ProjectItem ProjectItem)
        {
            AddItem(ProjectItem);
        }

        private void solutionEvents_ProjectAdded(Project project)
        {
            wrapper.AddFile(project.FileName);
            ProjectItems items = project.ProjectItems;
            AddItems(items);
        }

        private void AddItems(ProjectItems items)
        {
            foreach (ProjectItem item in items)
            {
                AddItem(item);
                AddItems(item.ProjectItems);
            }
        }

        private void AddItem(ProjectItem item)
        {
            for (short i = 0; i < item.FileCount; ++i)
            {
                string filename = item.get_FileNames(i);
                wrapper.AddFile(filename);
            }
        }


        /// <summary>
        /// This function is the callback used to execute a command when the a menu item is clicked.
        /// See the Initialize method to see how the menu item is associated to this function using
        /// the OleMenuCommandService service and the MenuCommand class.
        /// </summary>

        #region IVsRunningDocTableEvents3 Members

        public int OnAfterFirstDocumentLock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining,
                                            uint dwEditLocksRemaining)
        {
            return VSConstants.S_OK;
        }

        public int OnBeforeLastDocumentUnlock(uint docCookie, uint dwRDTLockType, uint dwReadLocksRemaining,
                                              uint dwEditLocksRemaining)
        {
            return VSConstants.S_OK;
        }


        public int OnAfterAttributeChange(uint docCookie, uint grfAttribs)
        {
            return VSConstants.S_OK;
        }

        public int OnBeforeDocumentWindowShow(uint docCookie, int fFirstShow, IVsWindowFrame pFrame)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterDocumentWindowHide(uint docCookie, IVsWindowFrame pFrame)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterAttributeChangeEx(uint docCookie, uint grfAttribs, IVsHierarchy pHierOld, uint itemidOld,
                                            string pszMkDocumentOld, IVsHierarchy pHierNew, uint itemidNew,
                                            string pszMkDocumentNew)
        {
            return VSConstants.S_OK;
        }

        private string fileSavedAs = null;
        private uint fileCookie = 0;

        public int OnAfterSave(uint docCookie)
        {
            if (docCookie == fileCookie)
            {
                uint flags;
                uint locks;
                uint editlocks;
                string filename;
                IVsHierarchy hier;
                IntPtr unk;
                uint id;
                docTable.GetDocumentInfo(docCookie, out flags, out locks, out editlocks, out filename, out hier,
                                         out id, out unk);
                if (fileSavedAs == null || fileSavedAs != filename)
                {
                    wrapper.CheckAfterSave(filename);
                }
            }
            fileSavedAs = null;
            fileCookie = 0;

            return VSConstants.S_OK;
        }

        public int OnBeforeSave(uint docCookie)
        {
            // This is what we are interested in.
            uint flags;
            uint locks;
            uint editlocks;
            string filename;
            IVsHierarchy hier;
            IntPtr unk;
            uint id;
            docTable.GetDocumentInfo(docCookie, out flags, out locks, out editlocks, out filename, out hier,
                                     out id, out unk);
            FileInfo fi = new FileInfo(filename);
            if (fi.Exists)
            {
                wrapper.CheckBeforeSave(filename);
                fileSavedAs = filename;
            }
            else
            {
                fileSavedAs = null;
            }
            fileCookie = docCookie;
            return VSConstants.S_OK;
        }

        #endregion

        #region IVsTrackProjectDocumentsEvents2 Members

        public int OnQueryAddFiles(IVsProject pProject, int cFiles, string[] rgpszMkDocuments,
                                   VSQUERYADDFILEFLAGS[] rgFlags,
                                   VSQUERYADDFILERESULTS[] pSummaryResult, VSQUERYADDFILERESULTS[] rgResults)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterAddFilesEx(int cProjects, int cFiles, IVsProject[] rgpProjects, int[] rgFirstIndices,
                                     string[] rgpszMkDocuments, VSADDFILEFLAGS[] rgFlags)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterAddDirectoriesEx(int cProjects, int cDirectories, IVsProject[] rgpProjects,
                                           int[] rgFirstIndices,
                                           string[] rgpszMkDocuments, VSADDDIRECTORYFLAGS[] rgFlags)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterRemoveFiles(int cProjects, int cFiles, IVsProject[] rgpProjects, int[] rgFirstIndices,
                                      string[] rgpszMkDocuments, VSREMOVEFILEFLAGS[] rgFlags)
        {
            logger.WriteLine(0, "Got remove for {0} files.", cFiles);
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("Do you wish to delete the following files from perforce?");
            List<string> files = new List<string>();

            for (int i = 0; i < cFiles; ++i)
            {
                string filename = rgpszMkDocuments[i];
                files.Add(filename);
                sb.AppendFormat("    {0}\n", filename);
            }
            DialogResult dr = MessageBox.Show(sb.ToString(), "Delete Files?", MessageBoxButtons.YesNo);
            if (dr != DialogResult.Yes)
                return VSConstants.S_OK;
            foreach (string s in files)
            {
                wrapper.DeleteFile(s);
            }
            return VSConstants.S_OK;
        }

        public int OnAfterRemoveDirectories(int cProjects, int cDirectories, IVsProject[] rgpProjects,
                                            int[] rgFirstIndices,
                                            string[] rgpszMkDocuments, VSREMOVEDIRECTORYFLAGS[] rgFlags)
        {
            return VSConstants.S_OK;
        }

        public int OnQueryRenameFiles(IVsProject pProject, int cFiles, string[] rgszMkOldNames, string[] rgszMkNewNames,
                                      VSQUERYRENAMEFILEFLAGS[] rgFlags, VSQUERYRENAMEFILERESULTS[] pSummaryResult,
                                      VSQUERYRENAMEFILERESULTS[] rgResults)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterRenameFiles(int cProjects, int cFiles, IVsProject[] rgpProjects, int[] rgFirstIndices,
                                      string[] rgszMkOldNames, string[] rgszMkNewNames, VSRENAMEFILEFLAGS[] rgFlags)
        {
            logger.WriteLine(0, "Got rename for {0} files.", cFiles);
            for (int i = 0; i < cFiles; ++i)
            {
                wrapper.RenameFile(rgszMkOldNames[i], rgszMkNewNames[i]);
            }
            return VSConstants.S_OK;
        }

        public int OnQueryRenameDirectories(IVsProject pProject, int cDirs, string[] rgszMkOldNames,
                                            string[] rgszMkNewNames,
                                            VSQUERYRENAMEDIRECTORYFLAGS[] rgFlags,
                                            VSQUERYRENAMEDIRECTORYRESULTS[] pSummaryResult,
                                            VSQUERYRENAMEDIRECTORYRESULTS[] rgResults)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterRenameDirectories(int cProjects, int cDirs, IVsProject[] rgpProjects, int[] rgFirstIndices,
                                            string[] rgszMkOldNames, string[] rgszMkNewNames,
                                            VSRENAMEDIRECTORYFLAGS[] rgFlags)
        {
            return VSConstants.S_OK;
        }

        public int OnQueryAddDirectories(IVsProject pProject, int cDirectories, string[] rgpszMkDocuments,
                                         VSQUERYADDDIRECTORYFLAGS[] rgFlags, VSQUERYADDDIRECTORYRESULTS[] pSummaryResult,
                                         VSQUERYADDDIRECTORYRESULTS[] rgResults)
        {
            return VSConstants.S_OK;
        }

        public int OnQueryRemoveFiles(IVsProject pProject, int cFiles, string[] rgpszMkDocuments,
                                      VSQUERYREMOVEFILEFLAGS[] rgFlags, VSQUERYREMOVEFILERESULTS[] pSummaryResult,
                                      VSQUERYREMOVEFILERESULTS[] rgResults)
        {
            return VSConstants.S_OK;
        }

        public int OnQueryRemoveDirectories(IVsProject pProject, int cDirectories, string[] rgpszMkDocuments,
                                            VSQUERYREMOVEDIRECTORYFLAGS[] rgFlags,
                                            VSQUERYREMOVEDIRECTORYRESULTS[] pSummaryResult,
                                            VSQUERYREMOVEDIRECTORYRESULTS[] rgResults)
        {
            return VSConstants.S_OK;
        }

        public int OnAfterSccStatusChanged(int cProjects, int cFiles, IVsProject[] rgpProjects, int[] rgFirstIndices,
                                           string[] rgpszMkDocuments, uint[] rgdwSccStatus)
        {
            return VSConstants.S_OK;
        }

        #endregion

        #region Command Handlers

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4Diff)]
        private void DiffItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelection(false);

            if (CheckItemCount(items, "diff {0} files", 2))
            {
                items.ForEach(wrapper.DisplayDiff);
            }
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4History)]
        private void HistoryItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelection(false);

            if (CheckItemCount(items, "get history for {0} files", 2))
            {
                items.ForEach(wrapper.DisplayHistory);
            }
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4Win)]
        private void WinItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelection(false);

            if (CheckItemCount(items, "open p4win for {0} files", 2))
            {
                items.ForEach(wrapper.DisplayBrowser);
            }
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4Revert)]
        private void RevertItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelection(false);

            if (CheckItemCount(items, "revert {0} files", 1))
            {
                items.ForEach(wrapper.Revert);
            }
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4Delete)]
        private void DeleteItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelection(false);

            if (CheckItemCount(items, "delete {0} files", 1))
            {
                items.ForEach(wrapper.Revert);
            }
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4Edit)]
        private void EditItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelection(true);

            items.ForEach(wrapper.OpenForEdit);
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4EditTree)]
        private void EditTreeItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelectionTree();

            items.ForEach(wrapper.OpenForEdit);
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4AddTree)]
        private void AddTreeItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelectionTree();

            items.ForEach(wrapper.AddFile);
        }

        [OleCommandHandler(GuidList.guidP4VsCmdSetString, PkgCmdIDList.cmdidRunP4Add)]
        private void AddItemCallback(object sender, EventArgs e)
        {
            // Show a Message Box to prove we were here
            List<string> items = GetSolutionSelection(true);

            items.ForEach(wrapper.AddFile);
        }


        private bool CheckItemCount(List<string> items, string what, int threshold)
        {
            if (items.Count >= threshold)
            {
                string txt = string.Format(what, items.Count);
                IVsUIShell uiShell = (IVsUIShell) GetService(typeof (SVsUIShell));
                Guid clsid = Guid.Empty;
                int result;
                uiShell.ShowMessageBox(
                    0,
                    ref clsid,
                    "P4VsPkg",
                    string.Format(CultureInfo.CurrentCulture, "Request to {0}. Press OK to proceed.", txt),
                    string.Empty,
                    0,
                    OLEMSGBUTTON.OLEMSGBUTTON_OKCANCEL,
                    OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND,
                    OLEMSGICON.OLEMSGICON_WARNING,
                    0, // false
                    out result);
                return result == 1;
            }
            return true;
        }

        #endregion

        #region UIHierarchy helpers

        private List<string> GetSolutionSelection(bool includeSubItems)
        {
            Window solutionExplorer = dte.Windows.Item(Constants.vsWindowKindSolutionExplorer);
            UIHierarchy hierarchy = (UIHierarchy) solutionExplorer.Object;
            IEnumerable selected = hierarchy.SelectedItems as IEnumerable;
            List<string> items = new List<string>();
            foreach (UIHierarchyItem item in selected)
            {
                Project p = item.Object as Project;
                if (p != null)
                {
                    items.Add(p.FileName);
                    continue;
                }
                ProjectItem pi = item.Object as ProjectItem;
                if (pi != null)
                {
                    if (pi.SubProject != null)
                    {
                        items.Add(pi.SubProject.FileName);
                    }
                    else
                    {
                        AddFilesFromItem(items, pi, includeSubItems);
                    }
                    continue;
                }
                Solution2 soln = item.Object as Solution2;
                if (soln != null)
                {
                    items.Add(soln.FileName);
                    continue;
                }
            }
            return items;
        }

        private List<string> GetSolutionSelectionTree()
        {
            Window solutionExplorer = dte.Windows.Item(Constants.vsWindowKindSolutionExplorer);
            UIHierarchy hierarchy = (UIHierarchy) solutionExplorer.Object;
            IEnumerable selected = hierarchy.SelectedItems as IEnumerable;
            List<string> items = new List<string>();
            foreach (UIHierarchyItem item in selected)
            {
                ProjectItem pi = item.Object as ProjectItem;
                if (pi != null)
                {
                    if (pi.SubProject != null)
                    {
                        AddProject(items, pi.SubProject);
                    }
                    else
                    {
                        AddFilesFromItem(items, pi, true);
                    }
                    continue;
                }
                Solution2 soln = item.Object as Solution2;
                if (soln != null)
                {
                    items.Add(soln.FileName);
                    AddProjects(items, soln.Projects);
                    continue;
                }
                Project p = item.Object as Project;
                if (p != null)
                {
                    items.Add(p.FileName);
                    AddProjectItems(items, p.ProjectItems);
                    continue;
                }
            }
            Dictionary<string, string> unique = new Dictionary<string, string>();
            foreach (string s in items)
            {
                unique[s] = s;
            }
            items.Clear();
            foreach (string s in unique.Values)
            {
                items.Add(s);
            }
            return items;
        }

        private void AddProjects(ICollection<string> items, Projects projects)
        {
            foreach (Project project in projects)
            {
                AddProject(items, project);
            }
        }

        private void AddProject(ICollection<string> items, Project project)
        {
            items.Add(project.FileName);
            AddProjectItems(items, project.ProjectItems);
        }

        private void AddFilesFromItem(ICollection<string> items, ProjectItem pi, bool includeSubItems)
        {
            for (short i = 0; i < pi.FileCount; ++i)
            {
                if (pi.SubProject != null)
                {
                    AddProject(items, pi.SubProject);
                }
                else
                {
                    items.Add(pi.get_FileNames(i));
                    if (includeSubItems)
                    {
                        ProjectItems projectItems = pi.ProjectItems;
                        AddProjectItems(items, projectItems);
                    }
                }
            }
        }

        private void AddProjectItems(ICollection<string> items, ProjectItems projectItems)
        {
            foreach (ProjectItem item in projectItems)
            {
                AddFilesFromItem(items, item, true);
            }
        }

        #endregion
    }
}