/*
 * QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
 * Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/

using System;
using System.ComponentModel.Design;
using System.Globalization;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
using EnvDTE80;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Diagnostics;
using System.Threading.Tasks;

namespace QuantConnect.VisualStudioPlugin
{
    /// <summary>
    /// Command handler for QuantConnect Solution Explorer menu buttons
    /// </summary>
    internal sealed class SolutionExplorerMenuCommand
    {
        /// <summary>
        /// Command IDs for Solution Explorer menu buttons
        /// </summary>
        private const int _sendForBacktestingCommandId = 0x0100;
        private const int _saveToQuantConnectCommandId = 0x0110;

        /// <summary>
        /// Command menu group (command set GUID).
        /// </summary>
        private static readonly Guid _commandSet = new Guid("00ce2ccb-74c7-42f4-bf63-52c573fc1532");

        /// <summary>
        /// VS Package that provides this command, not null.
        /// </summary>
        private readonly QuantConnectPackage _package;

        private readonly DTE2 _dte2;

        private ProjectFinder _projectFinder;

        /// <summary>
        /// Observer for the status of backtests launched from the plugin
        /// </summary>
        private readonly IBacktestObserver _backtestObserver;

        private readonly AuthenticationCommand _authenticationCommand;

        /// <summary>
        /// Instance of the solution explorer menu command.
        /// </summary>
        public static SolutionExplorerMenuCommand Instance
        {
            get;
            private set;
        }

        /// <summary>
        /// Gets the service provider from the owner package.
        /// </summary>
        private IServiceProvider _serviceProvider => _package;

        // Lazily create _projectFinder only when we have an opened solution
        private ProjectFinder _lazyProjectFinder => _projectFinder ?? (_projectFinder = CreateProjectFinder());

        private ProjectFinder CreateProjectFinder()
        {
            return new ProjectFinder(PathUtils.GetSolutionFolder(_dte2));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SolutionExplorerMenuCommand"/> class.
        /// Adds our command handlers for menu (commands must exist in the command table file)
        /// </summary>
        /// <param name="package">Owner package, not null.</param>
        private SolutionExplorerMenuCommand(Package package, IBacktestObserver backtestObserver)
        {
            if (package == null)
            {
                throw new ArgumentNullException(nameof(package));
            }

            _backtestObserver = backtestObserver;
            _package = package as QuantConnectPackage;
            _dte2 = _serviceProvider.GetService(typeof(SDTE)) as DTE2;
            _authenticationCommand = new AuthenticationCommand();

            var commandService = _serviceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
            if (commandService != null)
            {
                RegisterSendForBacktesting(commandService);
                RegisterSaveToQuantConnect(commandService);
            }
        }

        private void RegisterSendForBacktesting(OleMenuCommandService commandService)
        {
            var menuCommandId = new CommandID(_commandSet, _sendForBacktestingCommandId);
            var oleMenuItem = new OleMenuCommand(SendForBacktestingCallback, menuCommandId);
            commandService.AddCommand(oleMenuItem);
        }

        private void RegisterSaveToQuantConnect(OleMenuCommandService commandService)
        {
            var menuCommandId = new CommandID(_commandSet, _saveToQuantConnectCommandId);
            var oleMenuItem = new OleMenuCommand(SaveToQuantConnectCallback, menuCommandId);
            commandService.AddCommand(oleMenuItem);
        }

        /// <summary>
        /// Initializes the singleton instance of the command.
        /// </summary>
        /// <param name="package">Owner package, not null.</param>
        public static void Initialize(Package package, IBacktestObserver backtestObserver)
        {
            Instance = new SolutionExplorerMenuCommand(package, backtestObserver);
        }

        private void SendForBacktestingCallback(object sender, EventArgs e)
        {
            try
            {
                ExecuteOnProjectAsync(sender, async (selectedProjectId, selectedProjectName, files) =>
                {
                    var uploadResult = await System.Threading.Tasks.Task.Run(() =>
                        UploadFilesToServer(selectedProjectId, files));
                    if (!uploadResult)
                    {
                        return;
                    }

                    var compilationResult = await CompileProjectOnServer(selectedProjectId);
                    if (!compilationResult.Item1)
                    {
                        var errorDialog = new ErrorDialog("Compilation Error", compilationResult.Item2);
                        VsUtils.DisplayDialogWindow(errorDialog);
                        return;
                    }

                    var backtestResult = await BacktestProjectOnServer(selectedProjectId, compilationResult.Item2);
                    if (!backtestResult.Item1)
                    {
                        var errorDialog = new ErrorDialog("Backtest Failed", backtestResult.Item2.Error);
                        VsUtils.DisplayDialogWindow(errorDialog);
                        return;
                    }

                    var projectUrl = string.Format(
                        CultureInfo.CurrentCulture,
                        "https://www.quantconnect.com/terminal/#open/{0}/{1}",
                        selectedProjectId,
                        backtestResult.Item2.BacktestId
                    );
                    Process.Start(projectUrl);
                });
            }
            catch (Exception exception)
            {
                VsUtils.ShowErrorMessageBox(_serviceProvider, "QuantConnect Exception", exception.ToString());
            }
        }

        private void SaveToQuantConnectCallback(object sender, EventArgs e)
        {
            try
            {
                ExecuteOnProjectAsync(sender, (selectedProjectId, selectedProjectName, files) =>
                {
                    System.Threading.Tasks.Task.Factory.StartNew(() =>
                    {
                        UploadFilesToServer(selectedProjectId, files);
                    }, CancellationToken.None, TaskCreationOptions.AttachedToParent, TaskScheduler.Default);
                });
            }
            catch (Exception exception)
            {
                VsUtils.ShowErrorMessageBox(_serviceProvider, "QuantConnect Exception", exception.ToString());
            }
        }

        /// <summary>
        /// Uploads a list of files to a specific project at QuantConnect
        /// </summary>
        /// <param name="selectedProjectId">Target project Id</param>
        /// <param name="files">List of files to upload</param>
        /// <returns>Returns false if any file failed to be uploaded</returns>
        private bool UploadFilesToServer(int selectedProjectId, IEnumerable<SelectedItem> files)
        {
            VsUtils.DisplayInStatusBar(_serviceProvider, "Uploading files to server...");
            var api = AuthorizationManager.GetInstance().GetApi();
            // Counters to keep track of files uploaded or not
            var filesUploaded = 0;
            var filesNotUploaded = 0;
            foreach (var file in files)
            {
                api.DeleteProjectFile(selectedProjectId, file.FileName);
                try
                {
                    var fileContent = File.ReadAllText(file.FilePath);
                    var response = api.AddProjectFile(selectedProjectId, file.FileName, fileContent);
                    if (response.Success)
                    {
                        filesUploaded++;
                    }
                    else
                    {
                        VSActivityLog.Error("Failed to add project file " + file.FileName);
                        filesNotUploaded++;
                    }
                }
                catch (Exception exception)
                {
                    VSActivityLog.Error("Exception adding project file " + file.FileName + ". Exception " + exception);
                    filesNotUploaded++;
                }
            }
            // Update Status bar accordingly based on counters
            var message = "Files upload complete";
            message += (filesUploaded != 0) ? ". Uploaded " + filesUploaded : "";
            message += (filesNotUploaded != 0) ? ". Failed to upload " + filesNotUploaded : "";
            VsUtils.DisplayInStatusBar(_serviceProvider, message);

            // Return false if any file failed to be uploaded
            var result = filesNotUploaded == 0;
            if (!result)
            {
                VsUtils.ShowErrorMessageBox(_serviceProvider, "Upload Files Failed", message);
            }
            return result;
        }

        /// <summary>
        /// Compiles specific projectId at QuantConnect
        /// </summary>
        /// <param name="projectId">Target project Id</param>
        /// <returns>Tuple&lt;bool, string&gt;. Item1 is true if compilation succeeded.
        /// Item2 is compile Id if compilation succeeded else error message.</returns>
        private async Task<Tuple<bool, string>> CompileProjectOnServer(int projectId)
        {
            VsUtils.DisplayInStatusBar(_serviceProvider, "Compiling project...");
            var api = AuthorizationManager.GetInstance().GetApi();
            var compileStatus = await System.Threading.Tasks.Task.Run(() => api.CreateCompile(projectId));
            var compileId = compileStatus.CompileId;

            while (compileStatus.State == Api.CompileState.InQueue)
            {
                compileStatus = await System.Threading.Tasks.Task.Delay(2000).
                    ContinueWith(_ => api.ReadCompile(projectId, compileId));
            }

            if (compileStatus.State == Api.CompileState.BuildError)
            {
                // Default to show Errors, now it is coming empty so use Logs. Will only show First Error || Log
                var error = compileStatus.Errors.Count == 0 ?
                    compileStatus.Logs.FirstOrDefault() : compileStatus.Errors.FirstOrDefault();
                VsUtils.DisplayInStatusBar(_serviceProvider, "Error when compiling project");
                return new Tuple<bool, string>(false, error);
            }
            VsUtils.DisplayInStatusBar(_serviceProvider, "Compilation completed successfully");
            return new Tuple<bool, string>(true, compileStatus.CompileId);
        }

        /// <summary>
        /// Backtests specific projectId and compileId at QuantConnect
        /// </summary>
        /// <param name="projectId">Target project Id</param>
        /// <param name="compileId">Target compile Id</param>
        /// <returns>Tuple&lt;bool, string&gt;. Item1 is true if backtest succeeded.
        /// Item2 is the corresponding Api.Backtest instance</returns>
        private async Task<Tuple<bool, Api.Backtest>> BacktestProjectOnServer(int projectId, string compileId)
        {
            VsUtils.DisplayInStatusBar(_serviceProvider, "Backtesting project...");
            var api = AuthorizationManager.GetInstance().GetApi();
            var backtestName = BacktestNameProvider.GetNewName();
            var backtestStatus = await System.Threading.Tasks.Task.Run(() => api.CreateBacktest(projectId, compileId, backtestName));
            var backtestId = backtestStatus.BacktestId;

            // Notify observer new backtest
            _backtestObserver.BacktestCreated(projectId, backtestStatus);

            var errorPresent = false;
            while (backtestStatus.Progress < 1 && !errorPresent)
            {
                backtestStatus = await System.Threading.Tasks.Task.Delay(4000).
                    ContinueWith(_ => api.ReadBacktest(projectId, backtestId));

                errorPresent = !string.IsNullOrEmpty(backtestStatus.Error) ||
                               !string.IsNullOrEmpty(backtestStatus.StackTrace);
                // Notify observer backtest status
                _backtestObserver.BacktestStatusUpdated(projectId, backtestStatus);
            }

            // Notify observer backtest finished
            _backtestObserver.BacktestFinished(projectId, backtestStatus);
            if (errorPresent)
            {
                VsUtils.DisplayInStatusBar(_serviceProvider, "Error when backtesting project");
                return new Tuple<bool, Api.Backtest>(false, backtestStatus);
            }
            var successMessage = "Backtest completed successfully";
            VsUtils.DisplayInStatusBar(_serviceProvider, successMessage);
            return new Tuple<bool, Api.Backtest>(true, backtestStatus);
        }

        private async void ExecuteOnProjectAsync(object sender, Action<int, string, List<SelectedItem>> onProject)
        {
            if (await _authenticationCommand.Login(_serviceProvider, false))
            {
                var projects = await System.Threading.Tasks.Task.Run(() =>
                {
                    var api = AuthorizationManager.GetInstance().GetApi();
                    return api.ListProjects().Projects;
                });

                var projectNames = projects.Select(p => Tuple.Create(p.ProjectId, p.Name, p.Language)).ToList();

                var files = GetSelectedFiles(sender);
                var fileNames = files.Select(tuple => tuple.FileName).ToList();
                var suggestedProjectName = _lazyProjectFinder.ProjectNameForFiles(fileNames);
                var projectNameDialog = new ProjectNameDialog(projectNames, suggestedProjectName);
                VsUtils.DisplayDialogWindow(projectNameDialog);

                if (projectNameDialog.ProjectNameProvided)
                {
                    var selectedProjectName = projectNameDialog.SelectedProjectName;
                    var selectedProjectId = projectNameDialog.SelectedProjectId;
                    _lazyProjectFinder.AssociateProjectWith(selectedProjectName, fileNames);

                    if (!selectedProjectId.HasValue)
                    {
                        var newProjectLanguage = PathUtils.DetermineProjectLanguage(files.Select(f => f.FilePath).ToList());
                        if (!newProjectLanguage.HasValue)
                        {
                            VsUtils.ShowMessageBox(_serviceProvider, "Failed to determine project language",
                                $"Failed to determine programming laguage for a project");
                            return;
                        }

                        selectedProjectId = CreateQuantConnectProject(selectedProjectName, newProjectLanguage.Value);
                        if (!selectedProjectId.HasValue)
                        {
                            VsUtils.ShowMessageBox(_serviceProvider, "Failed to create a project", $"Failed to create a project {selectedProjectName}");
                        }
                        onProject.Invoke(selectedProjectId.Value, selectedProjectName, files);
                    }
                    else
                    {
                        onProject.Invoke(selectedProjectId.Value, selectedProjectName, files);
                    }
                }
            }
        }

        private int? CreateQuantConnectProject(string projectName, Language projectLanguage)
        {
            var api = AuthorizationManager.GetInstance().GetApi();
            var projectResponse = api.CreateProject(projectName, projectLanguage);
            if (!projectResponse.Success)
            {
                return null;
            }
            return projectResponse.Projects[0].ProjectId;
        }

        private List<SelectedItem> GetSelectedFiles(object sender)
        {
            var selectedFiles = new List<SelectedItem>();
            var selectedItems = (object[])_dte2.ToolWindows.SolutionExplorer.SelectedItems;
            foreach (EnvDTE.UIHierarchyItem selectedUIHierarchyItem in selectedItems)
            {
                if (selectedUIHierarchyItem.Object is EnvDTE.ProjectItem)
                {
                    var item = selectedUIHierarchyItem.Object as EnvDTE.ProjectItem;
                    var filePath = item.Properties.Item("FullPath").Value.ToString();
                    var selectedItem = new SelectedItem
                    {
                        FileName = item.Name,
                        FilePath = filePath
                    };
                    selectedFiles.Add(selectedItem);
                }
            }

            // Check if the user selected a folder, and include files in directories otherwise language inference breaks.
            // Also to maintain child folder structure on webclient tweak the filename to contain folders expressed in URI format.
            if (selectedFiles.Count == 1 &&
                string.IsNullOrEmpty(Path.GetExtension(selectedFiles.First().FilePath)))
            {
                var basePath = selectedFiles.First().FilePath;
                var nonFolders = Directory.GetFiles(selectedFiles.First().FilePath, "*", SearchOption.AllDirectories);

                selectedFiles = nonFolders.Select(c => new SelectedItem
                {
                    FileName = "/" + c.Replace(basePath, string.Empty).Replace("\\", "/"),
                    FilePath = c
                }).ToList();
            }

            return selectedFiles;
        }

        private class SelectedItem
        {
            public string FileName
            {
                get; set;
            }

            public string FilePath
            {
                get; set;
            }
        }
    }
}