/****************************************************************************
**
** Copyright (C) 2017 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;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml;
using System.Xml.Linq;
using QtVsTools.Core.QtMsBuild;
using System.Text.RegularExpressions;
using Microsoft.Build.Construction;
using Microsoft.Build.Execution;
using Microsoft.Build.Evaluation;
using QtVsTools.VisualStudio;
using QtVsTools.SyntaxAnalysis;
using EnvDTE;

namespace QtVsTools.Core
{
    using static HelperFunctions;
    using static RegExpr;

    public class MsBuildProject
    {
        class MsBuildXmlFile
        {
            public string filePath = "";
            public XDocument xml = null;
            public bool isDirty = false;
            public XDocument xmlCommitted = null;
            public bool isCommittedDirty = false;
        }

        enum Files
        {
            Project = 0,
            Filters,
            User,
            Count
        }
        MsBuildXmlFile[] files = new MsBuildXmlFile[(int)Files.Count];

        MsBuildProject()
        {
            for (int i = 0; i < files.Length; i++)
                files[i] = new MsBuildXmlFile();
        }

        MsBuildXmlFile this[Files file]
        {
            get
            {
                if ((int)file >= (int)Files.Count)
                    return files[0];
                return files[(int)file];
            }
        }

        public string ProjectXml
        {
            get
            {
                var xml = this[Files.Project].xml;
                if (xml == null)
                    return "";
                return xml.ToString(SaveOptions.None);
            }
        }

        private static XNamespace ns = "http://schemas.microsoft.com/developer/msbuild/2003";

        public static MsBuildProject Load(string pathToProject)
        {
            if (!File.Exists(pathToProject))
                return null;

            MsBuildProject project = new MsBuildProject();

            project[Files.Project].filePath = pathToProject;
            if (!LoadXml(project[Files.Project]))
                return null;

            project[Files.Filters].filePath = pathToProject + ".filters";
            if (File.Exists(project[Files.Filters].filePath) && !LoadXml(project[Files.Filters]))
                return null;

            project[Files.User].filePath = pathToProject + ".user";
            if (File.Exists(project[Files.User].filePath) && !LoadXml(project[Files.User]))
                return null;

            return project;
        }

        static bool LoadXml(MsBuildXmlFile xmlFile)
        {
            try {
                var xmlText = File.ReadAllText(xmlFile.filePath, Encoding.UTF8);
                using (var reader = XmlReader.Create(new StringReader(xmlText))) {
                    xmlFile.xml = XDocument.Load(reader, LoadOptions.SetLineInfo);
                }
            } catch (Exception) {
                return false;
            }
            xmlFile.xmlCommitted = new XDocument(xmlFile.xml);
            return true;
        }

        public bool Save()
        {
            foreach (var file in files) {
                if (file.isDirty) {
                    file.xml?.Save(file.filePath, SaveOptions.None);
                    file.isCommittedDirty = file.isDirty = false;
                }
            }
            return true;
        }

        void Commit()
        {
            foreach (var file in files.Where(x => x.xml != null)) {
                if (file.isDirty) {
                    //file was modified: sync committed copy
                    file.xmlCommitted = new XDocument(file.xml);
                    file.isCommittedDirty = true;
                } else {
                    //fail-safe: ensure non-dirty files are in sync with committed copy
                    file.xml = new XDocument(file.xmlCommitted);
                    file.isDirty = file.isCommittedDirty;
                }
            }
        }

        void Rollback()
        {
            foreach (var file in files.Where(x => x.xml != null)) {
                file.xml = new XDocument(file.xmlCommitted);
                file.isDirty = file.isCommittedDirty;
            }
        }

        public string GetProperty(string property_name)
        {
            var xProperty = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Elements()
                .Where(x => x.Name.LocalName == property_name)
                .FirstOrDefault();
            if (xProperty == null)
                return string.Empty;
            return xProperty.Value;
        }

        public string GetProperty(string item_type, string property_name)
        {
            var xProperty = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemDefinitionGroup")
                .Elements(ns + item_type)
                .Elements()
                .Where(x => x.Name.LocalName == property_name)
                .FirstOrDefault();
            if (xProperty == null)
                return string.Empty;
            return xProperty.Value;
        }

        public IEnumerable<string> GetItems(string item_type)
        {
            return this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Elements(ns + item_type)
                .Select((XElement x) => (string)x.Attribute("Include"));
        }

        public bool EnableMultiProcessorCompilation()
        {
            var xClCompileDefs = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemDefinitionGroup")
                .Elements(ns + "ClCompile");
            foreach (var xClCompileDef in xClCompileDefs)
                xClCompileDef.Add(new XElement(ns + "MultiProcessorCompilation", "true"));

            this[Files.Project].isDirty = true;
            Commit();
            return true;
        }

        /// <summary>
        /// Parser for project configuration conditional expressions of the type:
        ///
        ///     '$(Configuration)|$(Platform)'=='_TOKEN_|_TOKEN_'
        ///
        /// </summary>
        Parser _ConfigCondition;
        Parser ConfigCondition
        {
            get
            {
                if (_ConfigCondition == null) {
                    var config = new Token("Configuration", CharWord.Repeat());
                    var platform = new Token("Platform", CharWord.Repeat());
                    var expr = "'$(Configuration)|$(Platform)'=='" & config & "|" & platform & "'";
                    try {
                        _ConfigCondition = expr.Render();
                    } catch { }
                }
                return _ConfigCondition;
            }
        }

        /// <summary>
        /// Parser for project format version string:
        ///
        ///     QtVS_vNNN
        ///
        /// </summary>
        Parser _ProjectFormatVersion;
        Parser ProjectFormatVersion
        {
            get
            {
                if (_ProjectFormatVersion == null) {
                    var expr = "QtVS_v" & new Token("VERSION", Char['0', '9'].Repeat(3))
                    {
                        new Rule<int> { Capture(value => int.Parse(value)) }
                    };
                    try {
                        _ProjectFormatVersion = expr.Render();
                    } catch { }
                }
                return _ProjectFormatVersion;
            }
        }

        int? ParseProjectFormatVersion(string text)
        {
            if (ProjectFormatVersion == null)
                return null;
            try {
                return ProjectFormatVersion.Parse(text)
                    .GetValues<int>("VERSION")
                    .First();
            } catch {
                return null;
            }
        }

        const StringComparison IGNORE_CASE = StringComparison.InvariantCultureIgnoreCase;
        readonly StringComparer IGNORE_CASE_ = StringComparer.InvariantCultureIgnoreCase;

        /// <summary>
        /// Converts project format version to the latest version:
        ///  * Set latest project version;
        ///  * Add QtSettings property group;
        ///  * Set QtInstall property;
        ///  * Remove hard-coded macros, include paths and libs related to Qt modules.
        ///  * Set QtModules property;
        /// </summary>
        /// <returns>true if successful</returns>
        public bool UpdateProjectFormatVersion()
        {
            if (ConfigCondition == null)
                return false;

            // Get default Qt dir
            string defaultQtDir = null;
            var defaultVersionName = QtVersionManager.The().GetDefaultVersion();
            var defaultVersion = QtVersionManager.The().GetVersionInfo(defaultVersionName);
            if (defaultVersion != null)
                defaultQtDir = defaultVersion.qtDir;

            // Get project configurations
            var configs = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Elements(ns + "ProjectConfiguration");

            // Get project global properties
            var globals = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Where(x => (string)x.Attribute("Label") == "Globals")
                .FirstOrDefault();
            if (globals == null)
                return false;

            // Get project configuration properties
            var configProps = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Where(pg =>
                    (string)pg.Attribute("Label") == "Configuration"
                    && pg.Attribute("Condition") != null)
                .ToDictionary(pg => (string)pg.Attribute("Condition"));

            // Set Qt project format version
            var projKeyword = globals
                .Elements(ns + "Keyword")
                .Where(x => x.Value.StartsWith(Resources.qtProjectKeyword)
                    || x.Value.StartsWith(Resources.qtProjectV2Keyword))
                .FirstOrDefault();
            if (projKeyword == null)
                return false;
            var oldVersion = ParseProjectFormatVersion(projKeyword.Value);
            if (oldVersion.HasValue && oldVersion.Value == Resources.qtProjectFormatVersion)
                return true; // nothing to do!

            projKeyword.SetValue(string.Format("QtVS_v{0}", Resources.qtProjectFormatVersion));

            // Find import of qt.props
            var qtPropsImport = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ImportGroup")
                .Elements(ns + "Import")
                .Where(x => (string)x.Attribute("Project") == @"$(QtMsBuild)\qt.props")
                .FirstOrDefault();
            if (qtPropsImport == null)
                return false;

            var uncategorizedPropertyGroups = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Where(pg => pg.Attribute("Label") == null)
                .ToList();

            var propertyGroups = new Dictionary<string, XElement>();

            // Upgrading from <= v3.2?
            if (!oldVersion.HasValue
                || oldVersion.Value < Resources.qtMinFormatVersion_PropertyEval) {

                // Find import of default Qt properties
                var qtDefaultProps = this[Files.Project].xml
                    .Elements(ns + "Project")
                    .Elements(ns + "ImportGroup")
                    .Elements(ns + "Import")
                    .Where(pg => Path.GetFileName((string)pg.Attribute("Project"))
                        .Equals("qt_defaults.props", StringComparison.InvariantCultureIgnoreCase))
                    .Select(pg => pg.Parent)
                    .FirstOrDefault();

                // Create uncategorized property groups
                foreach (var config in configs) {
                    string condition = string.Format("'$(Configuration)|$(Platform)'=='{0}'",
                        (string)config.Attribute("Include"));
                    var group = new XElement(ns + "PropertyGroup",
                                    new XAttribute("Condition", condition));
                    propertyGroups[condition] = group;
                    // Insert uncategorized groups after Qt defaults, if found
                    if (qtDefaultProps != null)
                        qtDefaultProps.AddAfterSelf(group);
                }

                // Move uncategorized properties to newly created groups
                foreach (var pg in uncategorizedPropertyGroups) {
                    foreach (var p in pg.Elements().ToList()) {
                        var condition = p.Attribute("Condition") ?? pg.Attribute("Condition");
                        XElement configPropertyGroup = null;
                        if (condition != null)
                            propertyGroups.TryGetValue((string)condition, out configPropertyGroup);
                        if (configPropertyGroup != null) {
                            p.Remove();
                            p.SetAttributeValue("Condition", null);
                            configPropertyGroup.Add(p);
                        }
                    }
                    if (!pg.Elements().Any())
                        pg.Remove();
                }
            }

            // Upgrading from <= v3.1?
            if (!oldVersion.HasValue
                || oldVersion.Value < Resources.qtMinFormatVersion_GlobalQtMsBuildProperty) {

                // Move Qt/MSBuild path to global property
                var qtMsBuildProperty = globals
                    .ElementsAfterSelf(ns + "PropertyGroup")
                    .Elements(ns + "QtMsBuild")
                    .FirstOrDefault();
                if (qtMsBuildProperty != null) {
                    var qtMsBuildPropertyGroup = qtMsBuildProperty.Parent;
                    qtMsBuildProperty.Remove();
                    qtMsBuildProperty.SetAttributeValue("Condition",
                        (string)qtMsBuildPropertyGroup.Attribute("Condition"));
                    globals.Add(qtMsBuildProperty);
                    qtMsBuildPropertyGroup.Remove();
                }
            }
            if (oldVersion.HasValue
                && oldVersion.Value > Resources.qtMinFormatVersion_Settings) {
                this[Files.Project].isDirty = true;
                Commit();
                return true;
            }

            // Upgrading from v3.0?
            Dictionary<string, XElement> oldQtInstall = null;
            Dictionary<string, XElement> oldQtSettings = null;
            if (oldVersion.HasValue && oldVersion.Value == Resources.qtMinFormatVersion_Settings) {
                oldQtInstall = this[Files.Project].xml
                    .Elements(ns + "Project")
                    .Elements(ns + "PropertyGroup")
                    .Elements(ns + "QtInstall")
                    .ToDictionary(x => (string)x.Parent.Attribute("Condition"));
                oldQtInstall.Values.ToList()
                    .ForEach(x => x.Remove());

                oldQtSettings = this[Files.Project].xml
                    .Elements(ns + "Project")
                    .Elements(ns + "PropertyGroup")
                    .Where(x => (string)x.Attribute("Label") == "QtSettings")
                    .ToDictionary(x => (string)x.Attribute("Condition"));
                oldQtSettings.Values.ToList()
                    .ForEach(x => x.Remove());
            }

            // Find location for import of qt.props and for the QtSettings property group:
            // (cf. ".vcxproj file elements" https://docs.microsoft.com/en-us/cpp/build/reference/vcxproj-file-structure?view=vs-2019#vcxproj-file-elements)
            XElement insertionPoint = null;

            // * After the last UserMacros property group
            insertionPoint = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Where(x => (string)x.Attribute("Label") == "UserMacros")
                .LastOrDefault();

            // * After the last PropertySheets import group
            insertionPoint = (insertionPoint != null) ? insertionPoint : this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ImportGroup")
                .Where(x => (string)x.Attribute("Label") == "PropertySheets")
                .LastOrDefault();

            // * Before the first ItemDefinitionGroup
            insertionPoint = (insertionPoint != null) ? insertionPoint : this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemDefinitionGroup")
                .Select(x => x.ElementsBeforeSelf().Last())
                .FirstOrDefault();

            // * Before the first ItemGroup
            insertionPoint = (insertionPoint != null) ? insertionPoint : this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Select(x => x.ElementsBeforeSelf().Last())
                .FirstOrDefault();

            // * Before the import of Microsoft.Cpp.targets
            insertionPoint = (insertionPoint != null) ? insertionPoint : this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "Import")
                .Where(x =>
                    (string)x.Attribute("Project") == @"$(VCTargetsPath)\Microsoft.Cpp.targets")
                .Select(x => x.ElementsBeforeSelf().Last())
                .FirstOrDefault();

            // * At the end of the file
            insertionPoint = (insertionPoint != null) ? insertionPoint : this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements()
                .LastOrDefault();

            if (insertionPoint == null)
                return false;

            // Move import of qt.props to insertion point
            if (qtPropsImport.Parent.Elements().SingleOrDefault() == qtPropsImport)
                qtPropsImport.Parent.Remove(); // Remove import group
            else
                qtPropsImport.Remove(); // Remove import (group contains other imports)
            insertionPoint.AddAfterSelf(
                new XElement(ns + "ImportGroup",
                    new XAttribute("Condition", @"Exists('$(QtMsBuild)\qt.props')"),
                    new XElement(ns + "Import",
                        new XAttribute("Project", @"$(QtMsBuild)\qt.props"))));

            // Create QtSettings property group above import of qt.props
            var qtSettings = new List<XElement>();
            foreach (var config in configs) {
                var configQtSettings = new XElement(ns + "PropertyGroup",
                        new XAttribute("Label", "QtSettings"),
                        new XAttribute("Condition",
                            string.Format("'$(Configuration)|$(Platform)'=='{0}'",
                            (string)config.Attribute("Include"))));
                insertionPoint.AddAfterSelf(configQtSettings);
                qtSettings.Add(configQtSettings);
            }

            // Add uncategorized property groups
            foreach (XElement propertyGroup in propertyGroups.Values)
                insertionPoint.AddAfterSelf(propertyGroup);

            // Add import of default property values
            insertionPoint.AddAfterSelf(
                new XElement(ns + "ImportGroup",
                    new XAttribute("Condition", @"Exists('$(QtMsBuild)\qt_defaults.props')"),
                    new XElement(ns + "Import",
                        new XAttribute("Project", @"$(QtMsBuild)\qt_defaults.props"))));

            //// Upgrading from v3.0: move Qt settings to newly created import groups
            if (oldVersion.HasValue && oldVersion.Value == Resources.qtMinFormatVersion_Settings) {
                foreach (var configQtSettings in qtSettings) {
                    var configCondition = (string)configQtSettings.Attribute("Condition");

                    XElement oldConfigQtInstall;
                    if (oldQtInstall.TryGetValue(configCondition, out oldConfigQtInstall))
                        configQtSettings.Add(oldConfigQtInstall);

                    XElement oldConfigQtSettings;
                    if (oldQtSettings.TryGetValue(configCondition, out oldConfigQtSettings)) {
                        foreach (var qtSetting in oldConfigQtSettings.Elements())
                            configQtSettings.Add(qtSetting);
                    }
                }

                this[Files.Project].isDirty = true;
                Commit();
                return true;
            }

            //// Upgrading from v2.0

            // Get project user properties (old format)
            var userProps = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ProjectExtensions")
                .Elements(ns + "VisualStudio")
                .Elements(ns + "UserProperties")
                .FirstOrDefault();

            // Copy Qt build reference to QtInstall project property
            this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Where(x => ((string)x.Attribute("Label")) == Resources.projLabelQtSettings)
                .ToList()
                .ForEach(config =>
                {
                    string qtInstallValue = defaultVersionName;
                    if (userProps != null) {
                        string platform = null;
                        try {
                            platform = ConfigCondition
                                .Parse((string)config.Attribute("Condition"))
                                .GetValues<string>("Platform")
                                .FirstOrDefault();
                        } catch { }

                        if (!string.IsNullOrEmpty(platform)) {
                            var qtInstallName = string.Format("Qt5Version_x0020_{0}", platform);
                            qtInstallValue = (string)userProps.Attribute(qtInstallName);
                        }
                    }
                    if (!string.IsNullOrEmpty(qtInstallValue))
                        config.Add(new XElement(ns + "QtInstall", qtInstallValue));
                });

            // Get C++ compiler properties
            var compiler = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemDefinitionGroup")
                .Elements(ns + "ClCompile");

            // Get linker properties
            var linker = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemDefinitionGroup")
                .Elements(ns + "Link");

            // Qt module names, to copy to QtModules property
            var moduleNames = new HashSet<string>();

            // Qt module macros, to remove from compiler macros property
            var moduleDefines = new HashSet<string>();

            // Qt module includes, to remove from compiler include directories property
            var moduleIncludePaths = new HashSet<string>();

            // Qt module link libraries, to remove from liker dependencies property
            var moduleLibs = new HashSet<string>();

            // Go through all known Qt modules and check which ones are currently being used
            foreach (var module in QtModules.Instance.GetAvailableModules()) {

                if (IsModuleUsed(module, compiler, linker)) {

                    // Qt module names, to copy to QtModules property
                    if (!string.IsNullOrEmpty(module.proVarQT))
                        moduleNames.UnionWith(module.proVarQT.Split(' '));

                    // Qt module macros, to remove from compiler macros property
                    moduleDefines.UnionWith(module.Defines);

                    // Qt module includes, to remove from compiler include directories property
                    moduleIncludePaths.UnionWith(
                        module.IncludePath.Select(x => Path.GetFileName(x)));

                    // Qt module link libraries, to remove from liker dependencies property
                    moduleLibs.UnionWith(
                        module.AdditionalLibraries.Select(x => Path.GetFileName(x)));
                    moduleLibs.UnionWith(
                        module.AdditionalLibrariesDebug.Select(x => Path.GetFileName(x)));
                    moduleLibs.Add(module.LibRelease);
                    moduleLibs.Add(module.LibDebug);

                    if (IsPrivateIncludePathUsed(module, compiler)) {
                        // Qt private module names, to copy to QtModules property
                        moduleNames.UnionWith(module.proVarQT.Split(' ')
                            .Select(x => string.Format("{0}-private", x)));
                    }
                }
            }

            // Remove Qt module macros from compiler properties
            foreach (var defines in compiler.Elements(ns + "PreprocessorDefinitions")) {
                defines.SetValue(string.Join(";", defines.Value.Split(';')
                    .Where(x => !moduleDefines.Contains(x))));
            }

            // Remove Qt module include paths from compiler properties
            foreach (var inclPath in compiler.Elements(ns + "AdditionalIncludeDirectories")) {
                inclPath.SetValue(string.Join(";", inclPath.Value.Split(';')
                    .Select(x => Unquote(x))
                    // Exclude paths rooted on $(QTDIR)
                    .Where(x => !x.StartsWith("$(QTDIR)", IGNORE_CASE))));
            }

            // Remove Qt module libraries from linker properties
            foreach (var libs in linker.Elements(ns + "AdditionalDependencies")) {
                libs.SetValue(string.Join(";", libs.Value.Split(';')
                    .Where(x => !moduleLibs.Contains(Path.GetFileName(Unquote(x)), IGNORE_CASE_))));
            }

            // Remove Qt lib path from linker properties
            foreach (var libs in linker.Elements(ns + "AdditionalLibraryDirectories")) {
                libs.SetValue(string.Join(";", libs.Value.Split(';')
                    .Select(x => Unquote(x))
                    // Exclude paths rooted on $(QTDIR)
                    .Where(x => !x.StartsWith("$(QTDIR)", IGNORE_CASE))));
            }

            // Add Qt module names to QtModules project property
            this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Where(x => ((string)x.Attribute("Label")) == Resources.projLabelQtSettings)
                .ToList()
                .ForEach(x => x.Add(new XElement(ns + "QtModules", string.Join(";", moduleNames))));

            // Remove project user properties (old format)
            if (userProps != null) {
                userProps.Attributes().ToList().ForEach(userProp =>
                {
                    if (userProp.Name.LocalName == "lupdateOptions"
                        || userProp.Name.LocalName == "lupdateOnBuild"
                        || userProp.Name.LocalName == "lreleaseOptions"
                        || userProp.Name.LocalName == "MocDir"
                        || userProp.Name.LocalName == "MocOptions"
                        || userProp.Name.LocalName == "RccDir"
                        || userProp.Name.LocalName == "UicDir"
                        || userProp.Name.LocalName.StartsWith("Qt5Version_x0020_")) {
                        userProp.Remove();
                    }
                });
            }

            // Remove old properties from .user file
            if (this[Files.User].xml != null) {
                this[Files.User].xml
                    .Elements(ns + "Project")
                    .Elements(ns + "PropertyGroup")
                    .Elements()
                    .ToList()
                    .ForEach(userProp =>
                    {
                        if (userProp.Name.LocalName == "QTDIR"
                            || userProp.Name.LocalName == "QmlDebug"
                            || userProp.Name.LocalName == "QmlDebugSettings"
                            || (userProp.Name.LocalName == "LocalDebuggerCommandArguments"
                                && (string)userProp == "$(QmlDebug)"
                            )
                            || (userProp.Name.LocalName == "LocalDebuggerEnvironment"
                                && (string)userProp == "PATH=$(QTDIR)\\bin%3b$(PATH)"
                            )
                        ) {
                            userProp.Remove();
                        }
                    });
                this[Files.User].isDirty = true;
            }

            // Convert OutputFile --> <tool>Dir + <tool>FileName
            var qtItems = this[Files.Project].xml
                .Elements(ns + "Project")
                .SelectMany(x => x.Elements(ns + "ItemDefinitionGroup")
                    .Union(x.Elements(ns + "ItemGroup")))
                .SelectMany(x => x.Elements(ns + "QtMoc")
                    .Union(x.Elements(ns + "QtRcc"))
                    .Union(x.Elements(ns + "QtUic")));
            foreach (var qtItem in qtItems) {
                var outputFile = qtItem.Element(ns + "OutputFile");
                if (outputFile != null) {
                    var qtTool = qtItem.Name.LocalName;
                    var outDir = Path.GetDirectoryName(outputFile.Value);
                    var outFileName = Path.GetFileName(outputFile.Value);
                    if (!string.IsNullOrEmpty(outDir))
                        qtItem.Add(new XElement(ns + qtTool + "Dir", outDir));
                    else
                        qtItem.Add(new XElement(ns + qtTool + "Dir", "$(ProjectDir)"));
                    qtItem.Add(new XElement(ns + qtTool + "FileName", outFileName));
                }
            }

            // Remove old properties from project items
            var oldQtProps = new[] { "QTDIR", "InputFile", "OutputFile" };
            var oldCppProps = new[] { "IncludePath", "Define", "Undefine" };
            var oldPropsAny = oldQtProps.Union(oldCppProps);
            this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemDefinitionGroup")
                .Union(this[Files.Project].xml
                    .Elements(ns + "Project")
                    .Elements(ns + "ItemGroup"))
                .Elements().ToList().ForEach(item =>
                {
                    var itemName = item.Name.LocalName;
                    item.Elements().ToList().ForEach(itemProp =>
                    {
                        var propName = itemProp.Name.LocalName;
                        if ((itemName == "QtMoc" && oldPropsAny.Contains(propName))
                            || (itemName == "QtRcc" && oldQtProps.Contains(propName))
                            || (itemName == "QtUic" && oldQtProps.Contains(propName))
                            || (itemName == "QtRepc" && oldPropsAny.Contains(propName))
                        ) {
                            itemProp.Remove();
                        }
                    });
                });

            this[Files.Project].isDirty = true;
            Commit();
            return true;
        }

        bool IsModuleUsed(
            QtModule module,
            IEnumerable<XElement> compiler,
            IEnumerable<XElement> linker)
        {
            // Module .lib is present in linker additional dependencies
            if (linker.Elements(ns + "AdditionalDependencies")
                .SelectMany(x => x.Value.Split(';'))
                .Any(x => Path.GetFileName(Unquote(x)).Equals(module.LibRelease, IGNORE_CASE)
                    || Path.GetFileName(Unquote(x)).Equals(module.LibDebug, IGNORE_CASE))) {
                return true;
            }

            // Module macro is present in pre-processor definitions
            if (compiler.Elements(ns + "PreprocessorDefinitions")
                .SelectMany(x => x.Value.Split(';'))
                .Any(x => module.Defines.Contains(x))) {
                return true;
            }

            // Module is not present
            return false;
        }

        bool IsPrivateIncludePathUsed(
            QtModule module,
            IEnumerable<XElement> compiler)
        {
            // Module private header path is present in compiler include dirs
            var privateIncludePattern = new Regex(string.Format(
                @"^\$\(QTDIR\)[\\\/]include[\\\/]{0}[\\\/]\d+\.\d+\.\d+",
                module.LibraryPrefix));
            if (compiler.Elements(ns + "AdditionalIncludeDirectories")
                .SelectMany(x => x.Value.Split(';'))
                .Any(x => privateIncludePattern.IsMatch(x))) {
                return true;
            }

            // Private header path is not present
            return false;
        }

        public bool SetDefaultWindowsSDKVersion(string winSDKVersion)
        {
            var xGlobals = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "PropertyGroup")
                .Where(x => (string)x.Attribute("Label") == "Globals")
                .FirstOrDefault();
            if (xGlobals == null)
                return false;
            if (xGlobals.Element(ns + "WindowsTargetPlatformVersion") != null)
                return true;
            xGlobals.Add(
                new XElement(ns + "WindowsTargetPlatformVersion", winSDKVersion));

            this[Files.Project].isDirty = true;
            Commit();
            return true;
        }

        public bool AddQtMsBuildReferences()
        {
            var isQtMsBuildEnabled = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ImportGroup")
                .Elements(ns + "Import")
                .Where(x =>
                    x.Attribute("Project").Value == @"$(QtMsBuild)\qt.props")
                .Any();
            if (isQtMsBuildEnabled)
                return true;

            var xImportCppProps = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "Import")
                .Where(x =>
                    x.Attribute("Project").Value == @"$(VCTargetsPath)\Microsoft.Cpp.props")
                .FirstOrDefault();
            if (xImportCppProps == null)
                return false;

            var xImportCppTargets = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "Import")
                .Where(x =>
                    x.Attribute("Project").Value == @"$(VCTargetsPath)\Microsoft.Cpp.targets")
                .FirstOrDefault();
            if (xImportCppTargets == null)
                return false;

            xImportCppProps.AddAfterSelf(
                new XElement(ns + "PropertyGroup",
                    new XAttribute("Condition",
                        @"'$(QtMsBuild)'=='' " +
                        @"or !Exists('$(QtMsBuild)\qt.targets')"),
                    new XElement(ns + "QtMsBuild",
                        @"$(MSBuildProjectDirectory)\QtMsBuild")),

                new XElement(ns + "Target",
                    new XAttribute("Name", "QtMsBuildNotFound"),
                    new XAttribute("BeforeTargets", "CustomBuild;ClCompile"),
                    new XAttribute("Condition",
                        @"!Exists('$(QtMsBuild)\qt.targets') " +
                        @"or !Exists('$(QtMsBuild)\qt.props')"),
                    new XElement(ns + "Message",
                        new XAttribute("Importance", "High"),
                        new XAttribute("Text",
                            "QtMsBuild: could not locate qt.targets, qt.props; " +
                            "project may not build correctly."))),

                new XElement(ns + "ImportGroup",
                    new XAttribute("Condition", @"Exists('$(QtMsBuild)\qt.props')"),
                    new XElement(ns + "Import",
                        new XAttribute("Project", @"$(QtMsBuild)\qt.props"))));

            xImportCppTargets.AddAfterSelf(
                new XElement(ns + "ImportGroup",
                    new XAttribute("Condition", @"Exists('$(QtMsBuild)\qt.targets')"),
                    new XElement(ns + "Import",
                        new XAttribute("Project", @"$(QtMsBuild)\qt.targets"))));

            this[Files.Project].isDirty = true;
            Commit();
            return true;
        }

        delegate string ItemCommandLineReplacement(string itemName, string cmdLine);

        bool SetCommandLines(
            QtMsBuildContainer qtMsBuild,
            IEnumerable<XElement> configurations,
            IEnumerable<XElement> customBuilds,
            string toolExec,
            string itemType,
            string workingDir,
            IEnumerable<ItemCommandLineReplacement> extraReplacements)
        {
            var query = from customBuild in customBuilds
                        let itemName = customBuild.Attribute("Include").Value
                        from config in configurations
                        from command in customBuild.Elements(ns + "Command")
                        where command.Attribute("Condition").Value
                            == string.Format(
                                "'$(Configuration)|$(Platform)'=='{0}'",
                                (string)config.Attribute("Include"))
                        select new { customBuild, itemName, config, command };

            var projPath = this[Files.Project].filePath;
            bool error = false;
            using (var evaluator = new MSBuildEvaluator(this[Files.Project])) {
                foreach (var row in query) {

                    var configId = (string)row.config.Attribute("Include");
                    if (!row.command.Value.Contains(toolExec)) {
                        Messages.Print(string.Format(
                            "{0}: warning: [{1}] converting \"{2}\", configuration \"{3}\": " +
                            "tool not found: \"{4}\"; applying default options",
                            projPath, itemType, row.itemName, configId, toolExec));
                        continue;
                    }

                    XElement item;
                    row.customBuild.Add(item =
                        new XElement(ns + itemType,
                            new XAttribute("Include", row.itemName),
                            new XAttribute("ConfigName", configId)));
                    var configName = (string)row.config.Element(ns + "Configuration");
                    var platformName = (string)row.config.Element(ns + "Platform");

                    ///////////////////////////////////////////////////////////////////////////////
                    // Replace fixed values with VS macros
                    //
                    //   * Filename, e.g. foo.ui --> %(Filename)%(Extension)
                    var commandLine = row.command.Value
                        .Replace(Path.GetFileName(row.itemName), "%(Filename)%(Extension)",
                            StringComparison.InvariantCultureIgnoreCase);
                    //
                    //   * Context specific, e.g. ui_foo.h --> ui_%(FileName).h
                    foreach (var replace in extraReplacements)
                        commandLine = replace(row.itemName, commandLine);
                    //
                    //   * Configuration/platform, e.g. x64\Debug --> $(Platform)\$(Configuration)
                    commandLine = commandLine
                        .Replace(configName, "$(Configuration)",
                            StringComparison.InvariantCultureIgnoreCase)
                        .Replace(platformName, "$(Platform)",
                            StringComparison.InvariantCultureIgnoreCase);

                    evaluator.Properties.Clear();
                    foreach (var configProp in row.config.Elements())
                        evaluator.Properties.Add(configProp.Name.LocalName, (string)configProp);
                    if (!qtMsBuild.SetCommandLine(itemType, item, commandLine, evaluator)) {
                        int lineNumber = 1;
                        var errorLine = row.command as IXmlLineInfo;
                        if (errorLine != null && errorLine.HasLineInfo())
                            lineNumber = errorLine.LineNumber;

                        Messages.Print(string.Format(
                            "{0}({1}): error: [{2}] converting \"{3}\", configuration \"{4}\": " +
                            "failed to convert custom build command",
                            projPath, lineNumber, itemType, row.itemName, configId));

                        item.Remove();
                        error = true;
                    }
                }
            }

            return !error;
        }

        IEnumerable<XElement> GetCustomBuilds(string toolExecName)
        {
            return this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Elements(ns + "CustomBuild")
                .Where(x => x.Elements(ns + "Command")
                    .Where(y => (y.Value.Contains(toolExecName))).Any());
        }

        void FinalizeProjectChanges(List<XElement> customBuilds, string itemTypeName)
        {
            customBuilds
                .Elements().Where(
                    elem => elem.Name.LocalName != itemTypeName)
                .ToList().ForEach(oldElem => oldElem.Remove());

            customBuilds.Elements(ns + itemTypeName).ToList().ForEach(item =>
            {
                item.Elements().ToList().ForEach(prop =>
                {
                    string configName = prop.Parent.Attribute("ConfigName").Value;
                    prop.SetAttributeValue("Condition",
                        string.Format("'$(Configuration)|$(Platform)'=='{0}'", configName));
                    prop.Remove();
                    item.Parent.Add(prop);
                });
                item.Remove();
            });

            customBuilds.ForEach(customBuild =>
            {
                var filterCustomBuild = this[Files.Filters]?.xml
                    .Elements(ns + "Project")
                    .Elements(ns + "ItemGroup")
                    .Elements(ns + "CustomBuild")
                    .Where(filterItem =>
                        filterItem.Attribute("Include").Value
                        == customBuild.Attribute("Include").Value)
                    .FirstOrDefault();
                if (filterCustomBuild != null) {
                    filterCustomBuild.Name = ns + itemTypeName;
                    this[Files.Filters].isDirty = true;
                }

                customBuild.Name = ns + itemTypeName;
                this[Files.Project].isDirty = true;
            });
        }

        string AddGeneratedFilesPath(string includePathList)
        {
            HashSet<string> includes = new HashSet<string> {
                    QtVSIPSettings.GetMocDirectory(),
                    QtVSIPSettings.GetRccDirectory(),
                    QtVSIPSettings.GetUicDirectory(),
                };
            foreach (var includePath in includePathList.Split(new char[] { ';' }))
                includes.Add(includePath);
            return string.Join<string>(";", includes);
        }

        string CustomBuildMocInput(XElement cbt)
        {
            var commandLine = (string)cbt.Element(ns + "Command");
            Dictionary<QtMoc.Property, string> properties;
            using (var evaluator = new MSBuildEvaluator(this[Files.Project])) {
                if (!QtMsBuildContainer.QtMocInstance.ParseCommandLine(
                    commandLine, evaluator, out properties)) {
                    return (string)cbt.Attribute("Include");
                }
            }
            string ouputFile;
            if (!properties.TryGetValue(QtMoc.Property.InputFile, out ouputFile))
                return (string)cbt.Attribute("Include");
            return ouputFile;
        }

        bool RemoveGeneratedFiles(
            string projDir,
            List<CustomBuildEval> cbEvals,
            string configName,
            string itemName,
            Dictionary<string, List<XElement>> projItemsByPath,
            Dictionary<string, List<XElement>> filterItemsByPath)
        {
            //remove items with generated files
            bool hasGeneratedFiles = false;
            var cbEval = cbEvals
                .Where(x => x.ProjectConfig == configName && x.Identity == itemName)
                .FirstOrDefault();
            if (cbEval != null) {
                var outputFiles = cbEval.Outputs
                    .Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(x => HelperFunctions.CanonicalPath(
                        Path.IsPathRooted(x) ? x : Path.Combine(projDir, x)));
                var outputItems = new List<XElement>();
                foreach (var outputFile in outputFiles) {
                    List<XElement> mocOutput = null;
                    if (projItemsByPath.TryGetValue(outputFile, out mocOutput)) {
                        outputItems.AddRange(mocOutput);
                        hasGeneratedFiles |= hasGeneratedFiles ? true : mocOutput
                            .Where(x => !x.Elements(ns + "ExcludedFromBuild")
                                .Where(y =>
                                    (string)y.Attribute("Condition") == string.Format(
                                        "'$(Configuration)|$(Platform)'=='{0}'", configName)
                                    && y.Value == "true")
                                .Any())
                            .Any();
                    }
                    if (filterItemsByPath.TryGetValue(outputFile, out mocOutput))
                        outputItems.AddRange(mocOutput);
                }
                foreach (var item in outputItems.Where(x => x.Parent != null))
                    item.Remove();
            }
            return hasGeneratedFiles;
        }

        public bool ConvertCustomBuildToQtMsBuild()
        {
            var cbEvals = EvaluateCustomBuild();

            var qtMsBuild = new QtMsBuildContainer(new MsBuildConverterProvider());
            qtMsBuild.BeginSetItemProperties();

            var projDir = Path.GetDirectoryName(this[Files.Project].filePath);

            var configurations = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Elements(ns + "ProjectConfiguration");

            var projItemsByPath = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Elements()
                .Where(x => ((string)x.Attribute("Include"))
                    .IndexOfAny(Path.GetInvalidPathChars()) == -1)
                .GroupBy(x => HelperFunctions.CanonicalPath(
                    Path.Combine(projDir, (string)x.Attribute("Include"))),
                    StringComparer.InvariantCultureIgnoreCase)
                .ToDictionary(x => x.Key, x => new List<XElement>(x));

            var filterItemsByPath = (this[Files.Filters].xml != null)
                ? this[Files.Filters].xml
                    .Elements(ns + "Project")
                    .Elements(ns + "ItemGroup")
                    .Elements()
                    .Where(x => ((string)x.Attribute("Include"))
                        .IndexOfAny(Path.GetInvalidPathChars()) == -1)
                    .GroupBy(x => HelperFunctions.CanonicalPath(
                        Path.Combine(projDir, (string)x.Attribute("Include"))),
                        StringComparer.InvariantCultureIgnoreCase)
                    .ToDictionary(x => x.Key, x => new List<XElement>(x))
                : new Dictionary<string, List<XElement>>();

            var cppIncludePaths = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemDefinitionGroup")
                .Elements(ns + "ClCompile")
                .Elements(ns + "AdditionalIncludeDirectories");

            //add generated files path to C++ additional include dirs
            foreach (var cppIncludePath in cppIncludePaths)
                cppIncludePath.Value = AddGeneratedFilesPath((string)cppIncludePath);

            // replace each set of .moc.cbt custom build steps
            // with a single .cpp custom build step
            var mocCbtCustomBuilds = GetCustomBuilds(QtMoc.ToolExecName)
                .Where(x =>
                ((string)x.Attribute("Include")).EndsWith(".cbt",
                StringComparison.InvariantCultureIgnoreCase)
                || ((string)x.Attribute("Include")).EndsWith(".moc",
                StringComparison.InvariantCultureIgnoreCase))
                .GroupBy(cbt => CustomBuildMocInput(cbt));

            List<XElement> cbtToRemove = new List<XElement>();
            foreach (var cbtGroup in mocCbtCustomBuilds) {

                //create new CustomBuild item for .cpp
                var newCbt = new XElement(ns + "CustomBuild",
                    new XAttribute("Include", cbtGroup.Key),
                    new XElement(ns + "FileType", "Document"));

                //add properties from .moc.cbt items
                List<string> cbtPropertyNames = new List<string> {
                    "AdditionalInputs",
                    "Command",
                    "Message",
                    "Outputs",
                };
                foreach (var cbt in cbtGroup) {
                    var enabledProperties = cbt.Elements().Where(x =>
                        cbtPropertyNames.Contains(x.Name.LocalName)
                        && !x.Parent.Elements(ns + "ExcludedFromBuild").Where(y =>
                        (string)x.Attribute("Condition") == (string)y.Attribute("Condition"))
                        .Any());
                    foreach (var property in enabledProperties)
                        newCbt.Add(new XElement(property));
                    cbtToRemove.Add(cbt);
                }
                cbtGroup.First().AddBeforeSelf(newCbt);

                //remove ClCompile item (cannot have duplicate items)
                var cppMocItems = this[Files.Project].xml
                    .Elements(ns + "Project")
                    .Elements(ns + "ItemGroup")
                    .Elements(ns + "ClCompile")
                    .Where(x =>
                        cbtGroup.Key.Equals((string)x.Attribute("Include"),
                        StringComparison.InvariantCultureIgnoreCase));
                foreach (var cppMocItem in cppMocItems)
                    cppMocItem.Remove();

                //change type of item in filter
                cppMocItems = this[Files.Filters]?.xml
                    .Elements(ns + "Project")
                    .Elements(ns + "ItemGroup")
                    .Elements(ns + "ClCompile")
                    .Where(x =>
                        cbtGroup.Key.Equals((string)x.Attribute("Include"),
                        StringComparison.InvariantCultureIgnoreCase));
                foreach (var cppMocItem in cppMocItems)
                    cppMocItem.Name = ns + "CustomBuild";
            }

            //remove .moc.cbt CustomBuild items
            cbtToRemove.ForEach(x => x.Remove());

            //convert moc custom build steps
            var mocCustomBuilds = GetCustomBuilds(QtMoc.ToolExecName);
            if (!SetCommandLines(qtMsBuild, configurations, mocCustomBuilds,
                QtMoc.ToolExecName, QtMoc.ItemTypeName,
                Path.GetDirectoryName(this[Files.Project].filePath),
                new ItemCommandLineReplacement[]
                {
                    (item, cmdLine) => cmdLine.Replace(
                        string.Format(@"\moc_{0}.cpp", Path.GetFileNameWithoutExtension(item)),
                        @"\moc_%(Filename).cpp", StringComparison.InvariantCultureIgnoreCase)
                    .Replace(
                        string.Format(" -o moc_{0}.cpp", Path.GetFileNameWithoutExtension(item)),
                        @" -o $(ProjectDir)\moc_%(Filename).cpp",
                            StringComparison.InvariantCultureIgnoreCase),

                    (item, cmdLine) => cmdLine.Replace(
                        string.Format(@"\{0}.moc", Path.GetFileNameWithoutExtension(item)),
                        @"\%(Filename).moc", StringComparison.InvariantCultureIgnoreCase)
                    .Replace(
                        string.Format(" -o {0}.moc", Path.GetFileNameWithoutExtension(item)),
                        @" -o $(ProjectDir)\%(Filename).moc",
                            StringComparison.InvariantCultureIgnoreCase),
                })) {
                Rollback();
                return false;
            }
            List<XElement> mocDisableDynamicSource = new List<XElement>();
            foreach (var qtMoc in mocCustomBuilds.Elements(ns + QtMoc.ItemTypeName)) {
                var itemName = (string)qtMoc.Attribute("Include");
                var configName = (string)qtMoc.Attribute("ConfigName");

                //remove items with generated files
                var hasGeneratedFiles = RemoveGeneratedFiles(
                    projDir, cbEvals, configName, itemName,
                    projItemsByPath, filterItemsByPath);

                //set properties
                qtMsBuild.SetItemProperty(qtMoc,
                    QtMoc.Property.ExecutionDescription, "Moc'ing %(Identity)...");
                qtMsBuild.SetItemProperty(qtMoc,
                    QtMoc.Property.InputFile, "%(FullPath)");
                if (!HelperFunctions.IsSourceFile(itemName)) {
                    qtMsBuild.SetItemProperty(qtMoc,
                        QtMoc.Property.DynamicSource, "output");
                    if (!hasGeneratedFiles)
                        mocDisableDynamicSource.Add(qtMoc);
                } else {
                    qtMsBuild.SetItemProperty(qtMoc,
                        QtMoc.Property.DynamicSource, "input");
                }
                var includePath = qtMsBuild.GetPropertyChangedValue(
                    QtMoc.Property.IncludePath, itemName, configName);
                if (!string.IsNullOrEmpty(includePath)) {
                    qtMsBuild.SetItemProperty(qtMoc,
                        QtMoc.Property.IncludePath, AddGeneratedFilesPath(includePath));
                }
            }

            //convert rcc custom build steps
            var rccCustomBuilds = GetCustomBuilds(QtRcc.ToolExecName);
            if (!SetCommandLines(qtMsBuild, configurations, rccCustomBuilds,
                QtRcc.ToolExecName, QtRcc.ItemTypeName,
                Path.GetDirectoryName(this[Files.Project].filePath),
                new ItemCommandLineReplacement[]
                {
                    (item, cmdLine) => cmdLine.Replace(
                        string.Format(@"\qrc_{0}.cpp", Path.GetFileNameWithoutExtension(item)),
                        @"\qrc_%(Filename).cpp", StringComparison.InvariantCultureIgnoreCase)
                    .Replace(
                        string.Format(" -o qrc_{0}.cpp", Path.GetFileNameWithoutExtension(item)),
                        @" -o $(ProjectDir)\qrc_%(Filename).cpp",
                            StringComparison.InvariantCultureIgnoreCase),
                })) {
                Rollback();
                return false;
            }
            foreach (var qtRcc in rccCustomBuilds.Elements(ns + QtRcc.ItemTypeName)) {
                var itemName = (string)qtRcc.Attribute("Include");
                var configName = (string)qtRcc.Attribute("ConfigName");

                //remove items with generated files
                RemoveGeneratedFiles(projDir, cbEvals, configName, itemName,
                    projItemsByPath, filterItemsByPath);

                //set properties
                qtMsBuild.SetItemProperty(qtRcc,
                    QtRcc.Property.ExecutionDescription, "Rcc'ing %(Identity)...");
                qtMsBuild.SetItemProperty(qtRcc,
                    QtRcc.Property.InputFile, "%(FullPath)");
            }

            //convert repc custom build steps
            var repcCustomBuilds = GetCustomBuilds(QtRepc.ToolExecName);
            if (!SetCommandLines(qtMsBuild, configurations, repcCustomBuilds,
                QtRepc.ToolExecName, QtRepc.ItemTypeName,
                Path.GetDirectoryName(this[Files.Project].filePath),
                new ItemCommandLineReplacement[] { })) {
                Rollback();
                return false;
            }
            foreach (var qtRepc in repcCustomBuilds.Elements(ns + QtRepc.ItemTypeName)) {
                var itemName = (string)qtRepc.Attribute("Include");
                var configName = (string)qtRepc.Attribute("ConfigName");

                //remove items with generated files
                RemoveGeneratedFiles(projDir, cbEvals, configName, itemName,
                    projItemsByPath, filterItemsByPath);

                //set properties
                qtMsBuild.SetItemProperty(qtRepc,
                    QtRepc.Property.ExecutionDescription, "Repc'ing %(Identity)...");
                qtMsBuild.SetItemProperty(qtRepc,
                    QtRepc.Property.InputFile, "%(FullPath)");
            }


            //convert uic custom build steps
            var uicCustomBuilds = GetCustomBuilds(QtUic.ToolExecName);
            if (!SetCommandLines(qtMsBuild, configurations, uicCustomBuilds,
                QtUic.ToolExecName, QtUic.ItemTypeName,
                Path.GetDirectoryName(this[Files.Project].filePath),
                new ItemCommandLineReplacement[]
                {
                    (item, cmdLine) => cmdLine.Replace(
                        string.Format(@"\ui_{0}.h", Path.GetFileNameWithoutExtension(item)),
                        @"\ui_%(Filename).h", StringComparison.InvariantCultureIgnoreCase)
                    .Replace(
                        string.Format(" -o ui_{0}.h", Path.GetFileNameWithoutExtension(item)),
                        @" -o $(ProjectDir)\ui_%(Filename).h",
                            StringComparison.InvariantCultureIgnoreCase),
                })) {
                Rollback();
                return false;
            }
            foreach (var qtUic in uicCustomBuilds.Elements(ns + QtUic.ItemTypeName)) {
                var itemName = (string)qtUic.Attribute("Include");
                var configName = (string)qtUic.Attribute("ConfigName");

                //remove items with generated files
                RemoveGeneratedFiles(projDir, cbEvals, configName, itemName,
                    projItemsByPath, filterItemsByPath);

                //set properties
                qtMsBuild.SetItemProperty(qtUic,
                    QtUic.Property.ExecutionDescription, "Uic'ing %(Identity)...");
                qtMsBuild.SetItemProperty(qtUic,
                    QtUic.Property.InputFile, "%(FullPath)");
            }

            qtMsBuild.EndSetItemProperties();

            //disable dynamic C++ source for moc headers without generated files
            //(needed for the case of #include "moc_foo.cpp" in source file)
            foreach (var qtMoc in mocDisableDynamicSource) {
                qtMsBuild.SetItemProperty(qtMoc,
                    QtMoc.Property.DynamicSource, "false");
            }

            FinalizeProjectChanges(mocCustomBuilds.ToList(), QtMoc.ItemTypeName);
            FinalizeProjectChanges(rccCustomBuilds.ToList(), QtRcc.ItemTypeName);
            FinalizeProjectChanges(repcCustomBuilds.ToList(), QtRepc.ItemTypeName);
            FinalizeProjectChanges(uicCustomBuilds.ToList(), QtUic.ItemTypeName);

            this[Files.Project].isDirty = this[Files.Filters].isDirty = true;
            Commit();
            return true;
        }

        bool TryReplaceTextInPlace(ref string text, Regex findWhat, string newText)
        {
            var match = findWhat.Match(text);
            if (!match.Success)
                return false;
            do {
                text = text.Remove(match.Index, match.Length).Insert(match.Index, newText);
                match = findWhat.Match(text, match.Index);
            } while (match.Success);

            return true;
        }

        void ReplaceText(XElement xElem, Regex findWhat, string newText)
        {
            var elemValue = (string)xElem;
            if (!string.IsNullOrEmpty(elemValue)
                && TryReplaceTextInPlace(ref elemValue, findWhat, newText)) {
                xElem.Value = elemValue;
            }
        }

        void ReplaceText(XAttribute xAttr, Regex findWhat, string newText)
        {
            var attrValue = (string)xAttr;
            if (!string.IsNullOrEmpty(attrValue)
                && TryReplaceTextInPlace(ref attrValue, findWhat, newText)) {
                xAttr.Value = attrValue;
            }
        }

        /// <summary>
        /// All path separators
        /// </summary>
        static readonly char[] slashChars = new[]
        {
            Path.DirectorySeparatorChar,
            Path.AltDirectorySeparatorChar
        };

        /// <summary>
        /// Pattern that matches one path separator char
        /// </summary>
        static readonly RegExpr slash = CharSet[slashChars];

        /// <summary>
        /// Gets a RegExpr that matches a given path, regardless
        /// of case and varying directory separators
        /// </summary>
        static RegExpr GetPathPattern(string findWhatPath)
        {
            return
                // Make pattern case-insensitive
                IgnoreCase &
                // Split path string by directory separators
                findWhatPath.Split(slashChars, StringSplitOptions.RemoveEmptyEntries)
                // Convert path parts to RegExpr (escapes regex special chars)
                .Select(dirName => (RegExpr)dirName)
                // Join all parts, separated by path separator pattern
                .Aggregate((path, dirName) => path & slash & dirName);
        }

        public void ReplacePath(string oldPath, string newPath)
        {
            Uri srcUri = new Uri(Path.GetFullPath(oldPath));
            Uri projUri = new Uri(this[Files.Project].filePath);

            RegExpr absolutePath = GetPathPattern(srcUri.AbsolutePath);
            RegExpr relativePath = GetPathPattern(projUri.MakeRelativeUri(srcUri).OriginalString);

            Regex findWhat = (absolutePath | relativePath).Render().Regex;

            foreach (var xElem in this[Files.Project].xml.Descendants()) {
                if (!xElem.HasElements)
                    ReplaceText(xElem, findWhat, newPath);
                foreach (var xAttr in xElem.Attributes())
                    ReplaceText(xAttr, findWhat, newPath);
            }
            this[Files.Project].isDirty = true;
            Commit();
        }

        class MSBuildEvaluator : IVSMacroExpander, IDisposable
        {
            MsBuildXmlFile projFile;
            string tempProjFilePath;
            XElement evaluateTarget;
            XElement evaluateProperty;
            ProjectRootElement projRoot;
            public Dictionary<string, string> expansionCache;

            public Dictionary<string, string> Properties
            {
                get;
                private set;
            }

            public MSBuildEvaluator(MsBuildXmlFile projFile)
            {
                this.projFile = projFile;
                tempProjFilePath = string.Empty;
                evaluateTarget = evaluateProperty = null;
                expansionCache = new Dictionary<string, string>();
                Properties = new Dictionary<string, string>();
            }

            public void Dispose()
            {
                if (evaluateTarget != null) {
                    evaluateTarget.Remove();
                    if (File.Exists(tempProjFilePath))
                        File.Delete(tempProjFilePath);
                }
            }

            string ExpansionCacheKey(string stringToExpand)
            {
                var key = new StringBuilder();
                foreach (var property in Properties)
                    key.AppendFormat("{0};{1};", property.Key, property.Value);
                key.Append(stringToExpand);
                return key.ToString();
            }

            bool TryExpansionCache(string stringToExpand, out string expandedString)
            {
                return expansionCache.TryGetValue(
                    ExpansionCacheKey(stringToExpand), out expandedString);
            }

            void AddToExpansionCache(string stringToExpand, string expandedString)
            {
                expansionCache[ExpansionCacheKey(stringToExpand)] = expandedString;
            }

            public string ExpandString(string stringToExpand)
            {
                string expandedString;
                if (TryExpansionCache(stringToExpand, out expandedString))
                    return expandedString;

                if (evaluateTarget == null) {
                    projFile.xmlCommitted.Root.Add(evaluateTarget = new XElement(ns + "Target",
                        new XAttribute("Name", "MSBuildEvaluatorTarget"),
                        new XElement(ns + "PropertyGroup",
                            evaluateProperty = new XElement(ns + "MSBuildEvaluatorProperty"))));
                }
                if (stringToExpand != (string)evaluateProperty) {
                    evaluateProperty.SetValue(stringToExpand);
                    if (!string.IsNullOrEmpty(tempProjFilePath) && File.Exists(tempProjFilePath))
                        File.Delete(tempProjFilePath);
                    tempProjFilePath = Path.Combine(
                        Path.GetDirectoryName(projFile.filePath),
                        Path.GetRandomFileName());
                    if (File.Exists(tempProjFilePath))
                        File.Delete(tempProjFilePath);
                    projFile.xmlCommitted.Save(tempProjFilePath);
                    projRoot = ProjectRootElement.Open(tempProjFilePath);
                }
                var projInst = new ProjectInstance(projRoot, Properties,
                    null, new ProjectCollection());
                var buildRequest = new BuildRequestData(
                    projInst, new string[] { "MSBuildEvaluatorTarget" },
                    null, BuildRequestDataFlags.ProvideProjectStateAfterBuild);
                var buildResult = BuildManager.DefaultBuildManager.Build(
                    new BuildParameters(), buildRequest);
                expandedString = buildResult.ProjectStateAfterBuild
                    .GetPropertyValue("MSBuildEvaluatorProperty");

                AddToExpansionCache(stringToExpand, expandedString);
                return expandedString;
            }
        }

        class CustomBuildEval
        {
            public string ProjectConfig { get; set; }
            public string Identity { get; set; }
            public string AdditionalInputs { get; set; }
            public string Outputs { get; set; }
            public string Message { get; set; }
            public string Command { get; set; }
        }

        List<CustomBuildEval> EvaluateCustomBuild()
        {
            var eval = new List<CustomBuildEval>();

            var pattern = new Regex(@"{([^}]+)}{([^}]+)}{([^}]+)}{([^}]+)}{([^}]+)}");

            var projConfigs = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Elements(ns + "ProjectConfiguration");

            using (var evaluator = new MSBuildEvaluator(this[Files.Project])) {

                foreach (var projConfig in projConfigs) {

                    evaluator.Properties.Clear();
                    foreach (var configProp in projConfig.Elements())
                        evaluator.Properties.Add(configProp.Name.LocalName, (string)configProp);

                    var expandedValue = evaluator.ExpandString(
                        "@(CustomBuild->'" +
                            "{%(Identity)}" +
                            "{%(AdditionalInputs)}" +
                            "{%(Outputs)}" +
                            "{%(Message)}" +
                            "{%(Command)}')");

                    foreach (Match cbEval in pattern.Matches(expandedValue)) {
                        eval.Add(new CustomBuildEval
                        {
                            ProjectConfig = (string)projConfig.Attribute("Include"),
                            Identity = cbEval.Groups[1].Value,
                            AdditionalInputs = cbEval.Groups[2].Value,
                            Outputs = cbEval.Groups[3].Value,
                            Message = cbEval.Groups[4].Value,
                            Command = cbEval.Groups[5].Value,
                        });
                    }
                }
            }

            return eval;
        }

        public bool BuildTarget(string target)
        {
            if (this[Files.Project].isDirty)
                return false;

            var configurations = this[Files.Project].xml
                .Elements(ns + "Project")
                .Elements(ns + "ItemGroup")
                .Elements(ns + "ProjectConfiguration");

            using (var buildManager = new BuildManager()) {

                foreach (var config in configurations) {

                    var configProps = config.Elements()
                        .ToDictionary(x => x.Name.LocalName, x => x.Value);

                    var projectInstance = new ProjectInstance(this[Files.Project].filePath,
                        new Dictionary<string, string>(configProps)
                        { { "QtVSToolsBuild", "true" } },
                        null, new ProjectCollection());

                    var buildRequest = new BuildRequestData(projectInstance,
                        targetsToBuild: new[] { target },
                        hostServices: null,
                        flags: BuildRequestDataFlags.ProvideProjectStateAfterBuild);

                    var result = buildManager.Build(new BuildParameters(), buildRequest);
                    if (result.OverallResult != BuildResultCode.Success)
                        return false;

                }
            }
            return true;
        }

        static Regex ConditionParser =
            new Regex(@"\'\$\(Configuration[^\)]*\)\|\$\(Platform[^\)]*\)\'\=\=\'([^\']+)\'");

        class MsBuildConverterProvider : IPropertyStorageProvider
        {
            public string GetProperty(object propertyStorage, string itemType, string propertyName)
            {
                XElement xmlPropertyStorage = propertyStorage as XElement;
                if (xmlPropertyStorage == null)
                    return "";
                XElement item;
                if (xmlPropertyStorage.Name.LocalName == "ItemDefinitionGroup") {
                    item = xmlPropertyStorage.Element(ns + itemType);
                    if (item == null)
                        return "";
                } else {
                    item = xmlPropertyStorage;
                }
                var prop = item.Element(ns + propertyName);
                if (prop == null)
                    return "";
                return prop.Value;
            }

            public bool SetProperty(
                object propertyStorage,
                string itemType,
                string propertyName,
                string propertyValue)
            {
                XElement xmlPropertyStorage = propertyStorage as XElement;
                if (xmlPropertyStorage == null)
                    return false;
                XElement item;
                if (xmlPropertyStorage.Name.LocalName == "ItemDefinitionGroup") {
                    item = xmlPropertyStorage.Element(ns + itemType);
                    if (item == null)
                        xmlPropertyStorage.Add(item = new XElement(ns + itemType));
                } else {
                    item = xmlPropertyStorage;
                }
                var prop = item.Element(ns + propertyName);
                if (prop != null)
                    prop.Value = propertyValue;
                else
                    item.Add(new XElement(ns + propertyName, propertyValue));
                return true;
            }

            public bool DeleteProperty(
                object propertyStorage,
                string itemType,
                string propertyName)
            {
                XElement xmlPropertyStorage = propertyStorage as XElement;
                if (xmlPropertyStorage == null)
                    return false;
                XElement item;
                if (xmlPropertyStorage.Name.LocalName == "ItemDefinitionGroup") {
                    item = xmlPropertyStorage.Element(ns + itemType);
                    if (item == null)
                        return true;
                } else {
                    item = xmlPropertyStorage;
                }

                var prop = item.Element(ns + propertyName);
                if (prop != null)
                    prop.Remove();
                return true;
            }

            public string GetConfigName(object propertyStorage)
            {
                XElement xmlPropertyStorage = propertyStorage as XElement;
                if (xmlPropertyStorage == null)
                    return "";
                if (xmlPropertyStorage.Name.LocalName == "ItemDefinitionGroup") {
                    var configName = ConditionParser
                        .Match(xmlPropertyStorage.Attribute("Condition").Value);
                    if (!configName.Success || configName.Groups.Count <= 1)
                        return "";
                    return configName.Groups[1].Value;
                }
                return xmlPropertyStorage.Attribute("ConfigName").Value;
            }

            public string GetItemType(object propertyStorage)
            {
                XElement xmlPropertyStorage = propertyStorage as XElement;
                if (xmlPropertyStorage == null)
                    return "";
                if (xmlPropertyStorage.Name.LocalName == "ItemDefinitionGroup")
                    return "";
                return xmlPropertyStorage.Name.LocalName;
            }

            public string GetItemName(object propertyStorage)
            {
                XElement xmlPropertyStorage = propertyStorage as XElement;
                if (xmlPropertyStorage == null)
                    return "";
                if (xmlPropertyStorage.Name.LocalName == "ItemDefinitionGroup")
                    return "";
                return xmlPropertyStorage.Attribute("Include").Value;
            }

            public object GetParentProject(object propertyStorage)
            {
                XElement xmlPropertyStorage = propertyStorage as XElement;
                if (xmlPropertyStorage == null)
                    return "";
                if (xmlPropertyStorage.Document == null)
                    return null;
                return xmlPropertyStorage.Document.Root;
            }

            public object GetProjectConfiguration(object project, string configName)
            {
                XElement xmlProject = project as XElement;
                if (xmlProject == null)
                    return null;
                return xmlProject.Elements(ns + "ItemDefinitionGroup")
                    .Where(config => config.Attribute("Condition").Value.Contains(configName))
                    .FirstOrDefault();
            }

            public IEnumerable<object> GetItems(
                object project,
                string itemType,
                string configName = "")
            {
                XElement xmlProject = project as XElement;
                if (xmlProject == null)
                    return new List<object>();
                return
                    xmlProject.Elements(ns + "ItemGroup")
                    .Elements(ns + "CustomBuild")
                    .Elements(ns + itemType)
                    .Where(item => (
                        configName == ""
                        || item.Attribute("ConfigName").Value == configName))
                    .GroupBy(item => item.Attribute("Include").Value)
                    .Select(item => item.First());
            }
        }

    }
}