/****************************************************************************
**
** Copyright (C) 2016 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 Microsoft.VisualStudio.VCProjectEngine;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;

namespace QtVsTools.Core
{
    /// <summary>
    /// Wrapper for the VCCLCompilerTool class.
    /// </summary>
    /// For platforms other than Win32 the type VCCLCompilerTool is not available.
    /// See http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=220646&SiteID=1
    /// So we have to use the reflection system to get and set the desired properties.
    /// This class should be the only place where VCCLCompilerTool is used.
    /// Using VCCLCompilerTool directly will break the VS integration for Win CE.
    class CompilerToolWrapper
    {
        private VCCLCompilerTool compilerTool;
        private readonly Object compilerObj;
        private readonly Type compilerType;

        public static CompilerToolWrapper Create(VCConfiguration config)
        {
            CompilerToolWrapper wrapper = null;
            try {
                wrapper = new CompilerToolWrapper(((IVCCollection)config.Tools)
                    .Item("VCCLCompilerTool"));
            } catch {
            }

            return wrapper.IsNull() ? null : wrapper;
        }

        public static CompilerToolWrapper Create(VCFileConfiguration config)
        {
            CompilerToolWrapper wrapper = null;
            try {
                wrapper = new CompilerToolWrapper(config.Tool);
            } catch {
            }

            return wrapper.IsNull() ? null : wrapper;
        }

        public static CompilerToolWrapper Create(VCPropertySheet sheet)
        {
            CompilerToolWrapper wrapper = null;
            try {
                wrapper = new CompilerToolWrapper(((IVCCollection)sheet.Tools)
                    .Item("VCCLCompilerTool"));
            } catch {
            }

            return wrapper.IsNull() ? null : wrapper;
        }

        protected CompilerToolWrapper(object tool)
        {
            if (tool == null)
                return;

            compilerTool = tool as VCCLCompilerTool;
            if (compilerTool == null) {
                compilerObj = tool;
                compilerType = compilerObj.GetType();
            }
        }

        protected bool IsNull()
        {
            return compilerTool == null && compilerObj == null;
        }

        public List<string> AdditionalIncludeDirectories
        {
            get
            {
                var directories = GetAdditionalIncludeDirectories();
                if (directories == null)
                    return new List<string>();
                // double quotes are escaped
                directories = directories.Replace("\\\"", "\"");
                var dirArray = directories.Split(new[] { ';', ',' }, StringSplitOptions
                    .RemoveEmptyEntries);
                var lst = new List<string>(dirArray);
                var i = 0;
                while (i < lst.Count) {
                    var item = lst[i];
                    if (item.StartsWith("\"", StringComparison.Ordinal) && item.EndsWith("\"", StringComparison.Ordinal)) {
                        item = item.Remove(0, 1);
                        item = item.Remove(item.Length - 1, 1);
                        lst[i] = item;
                    }

                    if (lst[i].Length > 0)
                        ++i;
                    else
                        lst.RemoveAt(i);
                }
                return lst;
            }

            set
            {
                if (value == null) {
                    SetAdditionalIncludeDirectories(null);
                    return;
                }
                var newDirectories = string.Empty;
                var firstLoop = true;
                foreach (var dir in value) {
                    if (firstLoop)
                        firstLoop = false;
                    else
                        newDirectories += ";";

                    if (dir.IndexOfAny(new[] { ' ', '\t' }) > 0 || !Path.IsPathRooted(dir))
                        newDirectories += "\"" + dir + "\"";
                    else
                        newDirectories += dir;
                }
                if (newDirectories != GetAdditionalIncludeDirectories())
                    SetAdditionalIncludeDirectories(newDirectories);
            }
        }

        public void SetAdditionalIncludeDirectories(string value)
        {
            // Prevent setting of empty substring, as they break the build
            value = value.Replace("\"\",", string.Empty);
            if (compilerTool != null)
                compilerTool.AdditionalIncludeDirectories = value;
            else
                SetStringProperty("AdditionalIncludeDirectories", value);
        }

        public List<string> PreprocessorDefinitions
        {
            get
            {
                var ppdefsstr = GetPreprocessorDefinitions();
                if (string.IsNullOrEmpty(ppdefsstr))
                    return new List<string>();

                var ppdefs = ppdefsstr.Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
                return new List<string>(ppdefs);
            }
        }

        /// <summary>
        /// Adds a single preprocessor definition.
        /// </summary>
        /// <param name="value"></param>
        public void AddPreprocessorDefinition(string value)
        {
            var preprocessorDefs = GetPreprocessorDefinitions();
            if (preprocessorDefs != null) {
                var definesArray = preprocessorDefs.Split(new[] { ';', ',' },
                    StringSplitOptions.RemoveEmptyEntries);
                var definesList = new List<string>(definesArray);
                if (definesList.Contains(value))
                    return;
                if (preprocessorDefs.Length > 0
                    && !preprocessorDefs.EndsWith(";", StringComparison.Ordinal)
                    && !value.StartsWith(";", StringComparison.Ordinal)) {
                    preprocessorDefs += ";";
                }
            }
            preprocessorDefs += value;
            SetPreprocessorDefinitions(preprocessorDefs);
        }

        /// <summary>
        /// Removes a single preprocessor definition.
        /// </summary>
        /// <param name="value"></param>
        public void RemovePreprocessorDefinition(string value)
        {
            var preprocessorDefs = GetPreprocessorDefinitions();
            if (preprocessorDefs == null)
                return;

            var definesArray = preprocessorDefs.Split(new[] { ';', ',' },
                StringSplitOptions.RemoveEmptyEntries);
            var definesList = new List<string>(definesArray);
            if (!definesList.Remove(value))
                return;
            preprocessorDefs = "";
            var firstIteration = true;
            foreach (var define in definesList) {
                if (firstIteration)
                    firstIteration = false;
                else
                    preprocessorDefs += ';';
                preprocessorDefs += define;
            }
            NormalizePreprocessorDefinitions(ref preprocessorDefs);
            SetPreprocessorDefinitions(preprocessorDefs);
        }

        private static void NormalizePreprocessorDefinitions(ref string preprocessorDefs)
        {
            var idx = 0;
            while ((idx = preprocessorDefs.IndexOf(' ', idx)) != -1)
                preprocessorDefs = preprocessorDefs.Remove(idx, 1);

            preprocessorDefs = preprocessorDefs.Replace(',', ';');

            idx = 0;
            while ((idx = preprocessorDefs.IndexOf(";;", idx, StringComparison.Ordinal)) != -1)
                preprocessorDefs = preprocessorDefs.Remove(idx, 1);

            if (preprocessorDefs.EndsWith(";", StringComparison.Ordinal))
                preprocessorDefs = preprocessorDefs.Remove(preprocessorDefs.Length - 1);
        }

        public void SetPreprocessorDefinitions(string value)
        {
            if (compilerTool != null)
                compilerTool.PreprocessorDefinitions = value;
            else
                SetStringProperty("PreprocessorDefinitions", value);
        }

        public string GetPreprocessorDefinitions()
        {
            if (compilerTool != null)
                return compilerTool.PreprocessorDefinitions;
            return GetStringProperty("PreprocessorDefinitions");
        }

        public void AddAdditionalIncludeDirectories(string value)
        {
            if (string.IsNullOrEmpty(value))
                return;

            var directoryAdded = false;
            var directories = value.Split(new[] { ';', ',' }, StringSplitOptions
                .RemoveEmptyEntries);
            var lst = AdditionalIncludeDirectories;
            foreach (var directory in directories) {
                if (lst.Contains(directory))
                    continue;

                lst.Add(directory);
                directoryAdded = true;
            }

            if (directoryAdded)
                AdditionalIncludeDirectories = lst;
        }

        public string[] GetAdditionalIncludeDirectoriesList()
        {
            var includes = GetAdditionalIncludeDirectories().Split(',', ';');
            var fixedincludes = new string[includes.Length];
            var i = 0;
            foreach (var include in includes) {
                var incl = include;
                if (incl.StartsWith("\\\"", StringComparison.Ordinal) && incl.EndsWith("\\\"", StringComparison.Ordinal)) {
                    incl = incl.Remove(0, 2);
                    incl = incl.Remove(incl.Length - 2, 2);
                }
                fixedincludes[i++] = incl;
            }
            return fixedincludes;
        }

        public string GetAdditionalIncludeDirectories()
        {
            if (compilerTool != null)
                return compilerTool.AdditionalIncludeDirectories;
            return GetStringProperty("AdditionalIncludeDirectories");
        }

        public string GetPrecompiledHeaderFile()
        {
            if (compilerTool != null)
                return compilerTool.PrecompiledHeaderFile;
            return GetStringProperty("PrecompiledHeaderFile");
        }

        public string GetPrecompiledHeaderThrough()
        {
            if (compilerTool != null)
                return compilerTool.PrecompiledHeaderThrough;
            return GetStringProperty("PrecompiledHeaderThrough");
        }

        public pchOption GetUsePrecompiledHeader()
        {
            if (compilerTool != null)
                return compilerTool.UsePrecompiledHeader;

            var obj = compilerType.InvokeMember("UsePrecompiledHeader",
                BindingFlags.GetProperty, null, compilerObj, null);
            if (obj == null)
                return pchOption.pchNone;
            return (pchOption)obj;
        }

        public void SetDebugInformationFormat(debugOption value)
        {
            if (compilerTool != null) {
                compilerTool.DebugInformationFormat = value;
            } else {
                compilerType.InvokeMember(
                    "DebugInformationFormat",
                    BindingFlags.SetProperty,
                    null,
                    compilerObj,
                    new object[] { value });
            }
        }

        public runtimeLibraryOption RuntimeLibrary
        {
            get
            {
                if (compilerTool != null)
                    return compilerTool.RuntimeLibrary;

                var obj = compilerType.InvokeMember("RuntimeLibrary", BindingFlags.GetProperty,
                    null, compilerObj, null);
                if (obj == null)
                    return runtimeLibraryOption.rtMultiThreaded;
                return (runtimeLibraryOption)obj;
            }

            set
            {
                if (compilerTool == null) {
                    compilerType.InvokeMember("RuntimeLibrary", BindingFlags.SetProperty,
                        null, compilerObj, new object[] { value });
                } else {
                    compilerTool.RuntimeLibrary = value;
                }
            }
        }

        public void SetOptimization(optimizeOption value)
        {
            if (compilerTool != null) {
                compilerTool.Optimization = value;
            } else {
                compilerType.InvokeMember(
                    "Optimization",
                    BindingFlags.SetProperty,
                    null,
                    compilerObj,
                    new object[] { value });
            }
        }

        public void SetTreatWChar_tAsBuiltInType(bool value)
        {
            if (compilerTool != null) {
                compilerTool.TreatWChar_tAsBuiltInType = value;
            } else {
                compilerType.InvokeMember(
                    "TreatWChar_tAsBuiltInType",
                    BindingFlags.SetProperty,
                    null,
                    compilerObj,
                    new object[] { value });
            }
        }

        public void SetPrecompiledHeaderFile(string file)
        {
            if (compilerTool != null) {
                compilerTool.PrecompiledHeaderFile = file;
            } else {
                compilerType.InvokeMember(
                    "PrecompiledHeaderFile",
                    BindingFlags.SetProperty,
                    null,
                    compilerObj,
                    new object[] { file });
            }
        }

        public void SetPrecompiledHeaderThrough(string value)
        {
            if (compilerTool != null) {
                compilerTool.PrecompiledHeaderThrough = value;
            } else {
                compilerType.InvokeMember(
                    "PrecompiledHeaderThrough",
                    BindingFlags.SetProperty,
                    null,
                    compilerObj,
                    new object[] { value });
            }
        }

        public void SetUsePrecompiledHeader(pchOption value)
        {
            if (compilerTool != null) {
                compilerTool.UsePrecompiledHeader = value;
            } else {
                compilerType.InvokeMember(
                    "UsePrecompiledHeader",
                    BindingFlags.SetProperty,
                    null,
                    compilerObj,
                    new object[] { value });
            }
        }

        private void SetStringProperty(string name, string value)
        {
            compilerType.InvokeMember(
                name,
                BindingFlags.SetProperty,
                null,
                compilerObj,
                new object[] { value });
        }

        private string GetStringProperty(string name)
        {
            object obj;
            try {
                obj = compilerType.InvokeMember(name, BindingFlags.GetProperty,
                    null, compilerObj, null);
            } catch {
                obj = null;
            }
            if (obj == null)
                return string.Empty;
            return (string)obj;
        }

    }
}