/****************************************************************************
**
** Copyright (C) 2022 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt VS Tools.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using EnvDTE;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.VCProjectEngine;

namespace QtVsTools.Core.Legacy
{
    using Core;

    public static class QtProject
    {
        public static void MarkAsDesignerPluginProject(Core.QtProject qtPro)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            qtPro.Project.Globals["IsDesignerPlugin"] = true.ToString();
            if (!qtPro.Project.Globals.get_VariablePersists("IsDesignerPlugin"))
                qtPro.Project.Globals.set_VariablePersists("IsDesignerPlugin", true);
        }

        public static bool PromptChangeQtVersion(Project project, string oldVersion, string newVersion)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            var versionManager = Core.QtVersionManager.The();
            var viOld = versionManager.GetVersionInfo(oldVersion);
            var viNew = versionManager.GetVersionInfo(newVersion);

            if (viOld == null || viNew == null)
                return true;

            var oldIsWinRt = viOld.isWinRT();
            var newIsWinRt = viNew.isWinRT();

            if (newIsWinRt == oldIsWinRt || newIsWinRt == IsWinRT(project))
                return true;

            var caption = string.Format("Change Qt Version ({0})", project.Name);
            var text = string.Format(
                "Changing Qt version from {0} to {1}.\r\n" +
                "Project might not build. Are you sure?",
                newIsWinRt ? "Win32" : "WinRT",
                newIsWinRt ? "WinRT" : "Win32"
            );

            return MessageBox.Show(text, caption, MessageBoxButtons.YesNo, MessageBoxIcon.Warning)
                == DialogResult.Yes;
        }

        public static bool HasModule(Project project, int id, string qtVersion = null)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            var foundInIncludes = false;
            var foundInLibs = false;

            var vm = Core.QtVersionManager.The();
            var versionInfo = qtVersion != null ? vm.GetVersionInfo(qtVersion)
                : vm.GetVersionInfo(project);
            if (versionInfo == null)
                versionInfo = vm.GetVersionInfo(vm.GetDefaultVersion());
            if (versionInfo == null)
                return false; // neither a default or project Qt version
            var info = QtModules.Instance.Module(id, versionInfo.qtMajor);
            if (info == null)
                return false;

            var vcPro = project.Object as VCProject;
            foreach (VCConfiguration config in (IVCCollection)vcPro.Configurations) {
                var compiler = CompilerToolWrapper.Create(config);
                var linker = (VCLinkerTool)((IVCCollection)config.Tools).Item("VCLinkerTool");

                if (compiler != null) {
                    if (compiler.GetAdditionalIncludeDirectories() == null)
                        continue;
                    var incPathList = info.GetIncludePath();
                    var includeDirs = compiler.GetAdditionalIncludeDirectoriesList();
                    foundInIncludes = (incPathList.Count > 0);
                    foreach (var incPath in incPathList) {
                        var fixedIncludeDir = FixFilePathForComparison(incPath);
                        if (!includeDirs.Any(dir =>
                            FixFilePathForComparison(dir) == fixedIncludeDir)) {
                            foundInIncludes = false;
                            break;
                        }
                    }
                }

                if (foundInIncludes)
                    break;

                List<string> libs = null;
                if (linker != null) {
                    var linkerWrapper = new LinkerToolWrapper(linker);
                    libs = linkerWrapper.AdditionalDependencies;
                }

                if (libs != null) {
                    var moduleLibs = info.GetLibs(IsDebugConfiguration(config), versionInfo);
                    foundInLibs = moduleLibs.All(moduleLib => libs.Contains(moduleLib));
                }
            }
            return foundInIncludes || foundInLibs;
        }

        public static void AddModule(Project project, int id)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            if (HasModule(project, id))
                return;

            var vm = Core.QtVersionManager.The();
            var versionInfo = vm.GetVersionInfo(project);
            if (versionInfo == null)
                versionInfo = vm.GetVersionInfo(vm.GetDefaultVersion());

            var vcPro = project.Object as VCProject;
            foreach (VCConfiguration config in vcPro.Configurations as IVCCollection) {

                var info = QtModules.Instance.Module(id, versionInfo.qtMajor);
                if (Core.QtProject.GetFormatVersion(project) >= Resources.qtMinFormatVersion_Settings) {
                    var config3 = config as VCConfiguration3;
                    if (config3 == null)
                        continue;
                    if (!string.IsNullOrEmpty(info.proVarQT)) {
                        var qtModulesValue = config.GetUnevaluatedPropertyValue("QtModules");
                        var qtModules = new HashSet<string>(
                            !string.IsNullOrEmpty(qtModulesValue)
                                ? qtModulesValue.Split(';')
                                : new string[] { });
                        qtModules.UnionWith(info.proVarQT.Split(' '));
                        config3.SetPropertyValue(Resources.projLabelQtSettings, true,
                            "QtModules", string.Join(";", qtModules));
                    }
                    // In V3 project format, compiler and linker options
                    // required by modules are set by Qt/MSBuild.
                    continue;
                }

                var compiler = CompilerToolWrapper.Create(config);
                var linker = (VCLinkerTool)((IVCCollection)config.Tools).Item("VCLinkerTool");

                if (compiler != null) {
                    foreach (var define in info.Defines)
                        compiler.AddPreprocessorDefinition(define);

                    var incPathList = info.GetIncludePath();
                    foreach (var incPath in incPathList)
                        compiler.AddAdditionalIncludeDirectories(incPath);
                }
                if (linker != null) {
                    var moduleLibs = info.GetLibs(IsDebugConfiguration(config), versionInfo);
                    var linkerWrapper = new LinkerToolWrapper(linker);
                    var additionalDeps = linkerWrapper.AdditionalDependencies;
                    var dependenciesChanged = false;
                    if (additionalDeps == null || additionalDeps.Count == 0) {
                        additionalDeps = moduleLibs;
                        dependenciesChanged = true;
                    } else {
                        foreach (var moduleLib in moduleLibs) {
                            if (!additionalDeps.Contains(moduleLib)) {
                                additionalDeps.Add(moduleLib);
                                dependenciesChanged = true;
                            }
                        }
                    }
                    if (dependenciesChanged)
                        linkerWrapper.AdditionalDependencies = additionalDeps;
                }
            }
        }

        public static void RemoveModule(Project project, int id)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            var vm = Core.QtVersionManager.The();
            var versionInfo = vm.GetVersionInfo(project);
            if (versionInfo == null)
                versionInfo = vm.GetVersionInfo(vm.GetDefaultVersion());

            var vcPro = project.Object as VCProject;
            foreach (VCConfiguration config in (IVCCollection)vcPro.Configurations) {
                var compiler = CompilerToolWrapper.Create(config);
                var linker = (VCLinkerTool)((IVCCollection)config.Tools).Item("VCLinkerTool");

                var info = QtModules.Instance.Module(id, versionInfo.qtMajor);
                if (compiler != null) {
                    foreach (var define in info.Defines)
                        compiler.RemovePreprocessorDefinition(define);
                    var additionalIncludeDirs = compiler.AdditionalIncludeDirectories;
                    if (additionalIncludeDirs != null) {
                        var lst = new List<string>(additionalIncludeDirs);
                        foreach (var includePath in info.IncludePath) {
                            lst.Remove(includePath);
                            lst.Remove('\"' + includePath + '\"');
                        }
                        compiler.AdditionalIncludeDirectories = lst;
                    }
                }
                if (linker != null && linker.AdditionalDependencies != null) {
                    var linkerWrapper = new LinkerToolWrapper(linker);
                    var moduleLibs = info.GetLibs(IsDebugConfiguration(config), versionInfo);
                    var additionalDependencies = linkerWrapper.AdditionalDependencies;
                    var dependenciesChanged = false;
                    foreach (var moduleLib in moduleLibs)
                        dependenciesChanged |= additionalDependencies.Remove(moduleLib);
                    if (dependenciesChanged)
                        linkerWrapper.AdditionalDependencies = additionalDependencies;
                }
            }
        }
        
        internal static bool IsDesignerPluginProject(Core.QtProject qtPro)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            var b = false;
            if (qtPro.Project.Globals.get_VariablePersists("IsDesignerPlugin")) {
                var s = qtPro.Project.Globals["IsDesignerPlugin"] as string;
                try {
                    b = bool.Parse(s);
                } catch { }
            }
            return b;
        }


        private static bool IsWinRT(Project project)
        {
            ThreadHelper.ThrowIfNotOnUIThread();

            try {
                var vcProject = project.Object as VCProject;
                var vcConfigs = vcProject.Configurations as IVCCollection;
                var vcConfig = vcConfigs.Item(1) as VCConfiguration;
                var appType = vcConfig.GetEvaluatedPropertyValue("ApplicationType");
                if (appType == "Windows Store")
                    return true;
            } catch { }
            return false;
        }

        private static string FixFilePathForComparison(string path)
        {
            return HelperFunctions.NormalizeRelativeFilePath(path).ToLower();
        }

        private static bool IsDebugConfiguration(VCConfiguration conf)
        {
            var tool = CompilerToolWrapper.Create(conf);
            if (tool != null) {
                return tool.RuntimeLibrary == runtimeLibraryOption.rtMultiThreadedDebug
                    || tool.RuntimeLibrary == runtimeLibraryOption.rtMultiThreadedDebugDLL;
            }
            return false;
        }
    }
}