/****************************************************************************
**
** Copyright (C) 2020 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.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Microsoft.Win32;
using QtVsTools.Common;

namespace QtVsTools.Options
{
    using static EnumExt;

    public enum BuildHost
    {
        [String("Windows")] Windows,
        [String("Linux SSH")] LinuxSSH,
        [String("Linux WSL")] LinuxWSL,
    }

    public partial class QtVersionsTable : UserControl
    {
        public QtVersionsTable()
        {
            InitializeComponent();
        }

        public class Field
        {
            public string Value { get; set; }
            public Control Control { get; set; }
            public DataGridCell Cell { get; set; }
            public string ValidationError { get; set; }
            public bool IsValid => string.IsNullOrEmpty(ValidationError);
            public ToolTip ToolTip
                => IsValid ? null : new ToolTip() { Content = ValidationError };
            public int SelectionStart { get; set; }
        }

        public class Row
        {
            public enum FieldNames { IsDefault, VersionName, Host, Path, Compiler }

            public Dictionary<FieldNames, Field> _Fields;
            public Dictionary<FieldNames, Field> Fields => _Fields
                ?? (_Fields = GetValues<FieldNames>()
                    .Select(field => new KeyValuePair<FieldNames, Field>(field, null))
                    .ToDictionary(keyValue => keyValue.Key, keyValue => keyValue.Value));

            public Field FieldDefault => Fields[FieldNames.IsDefault]
                ?? (Fields[FieldNames.IsDefault] = new Field());
            public bool IsDefault
            {
                get => (FieldDefault.Value == true.ToString());
                set => FieldDefault.Value = value.ToString();
            }

            public Field FieldVersionName => Fields[FieldNames.VersionName]
                ?? (Fields[FieldNames.VersionName] = new Field());
            public string VersionName
            {
                get => FieldVersionName.Value;
                set => FieldVersionName.Value = value;
            }

            public Field FieldHost => Fields[FieldNames.Host]
                ?? (Fields[FieldNames.Host] = new Field());
            public BuildHost Host
            {
                get => FieldHost.Value.Cast(defaultValue: BuildHost.Windows);
                set => FieldHost.Value = value.Cast<string>();
            }

            public Field FieldPath => Fields[FieldNames.Path]
                ?? (Fields[FieldNames.Path] = new Field());
            public string Path
            {
                get => FieldPath.Value;
                set => FieldPath.Value = value;
            }

            public Field FieldCompiler => Fields[FieldNames.Compiler]
                ?? (Fields[FieldNames.Compiler] = new Field());
            public string Compiler
            {
                get => FieldCompiler.Value;
                set => FieldCompiler.Value = value;
            }

            public bool LastRow { get; set; }

            public bool DefaultEnabled => !IsDefault && !LastRow;
            public bool NameEnabled => !LastRow;
            public bool CompilerEnabled => (Host != BuildHost.Windows);
            public Visibility RowVisibility
                => LastRow ? Visibility.Hidden : Visibility.Visible;
            public Visibility ButtonAddVisibility
                => LastRow ? Visibility.Visible : Visibility.Hidden;
            public Visibility ButtonBrowseVisibility
                => (!LastRow && Host == BuildHost.Windows) ? Visibility.Visible : Visibility.Hidden;
            public Thickness PathMargin
                => new Thickness(((Host == BuildHost.Windows) ? 22 : 2), 0, 2, 0);
            public FontWeight FontWeight
                => IsDefault ? FontWeights.Bold : FontWeights.Normal;

            public static ImageSource _ExplorerIcon;
            public static ImageSource ExplorerIcon => _ExplorerIcon
                ?? (_ExplorerIcon = GetExplorerIcon());
        }

        public bool IsValid { get; private set; }

        Field FocusedField { get; set; }

        List<Row> _Rows;
        List<Row> Rows => _Rows ?? (_Rows = new List<Row>());
        public IEnumerable<Row> Versions => Rows.TakeWhile(item => !item.LastRow);

        public void UpdateVersions(IEnumerable<Row> versions)
        {
            Rows.Clear();
            Rows.AddRange(versions);
            Rows.Add(new Row { LastRow = true });
            DataGrid.ItemsSource = Rows;
            IsValid = true;
            FocusedField = null;
            Validate(true);
        }

        public IEnumerable<string> GetErrorMessages()
        {
            Validate(true);
            return Versions
                .SelectMany(v => v.Fields.Values.Select(f => f.ValidationError))
                .Where(s => !string.IsNullOrEmpty(s))
                .Distinct();
        }

        void Validate(bool mustRefresh)
        {
            /////////////////////////
            // Automatic cell values
            foreach (var version in Versions) {
                if (version.Host != BuildHost.Windows && version.Compiler == "msvc") {
                    version.Compiler = "g++";
                    version.FieldCompiler.SelectionStart = version.Compiler.Length;
                    mustRefresh = true;
                } else if (version.Host == BuildHost.Windows && version.Compiler != "msvc") {
                    version.Compiler = "msvc";
                    version.FieldCompiler.SelectionStart = version.Compiler.Length;
                    mustRefresh = true;
                }
            }

            ////////////////////////
            // Validate cell values
            string previousValidation;
            bool wasValid = IsValid;
            IsValid = true;
            foreach (var version in Versions) {

                //////////////////////
                // Default validation
                previousValidation = version.FieldDefault.ValidationError;
                version.FieldDefault.ValidationError = null;
                if (version.IsDefault && version.Host != BuildHost.Windows) {
                    version.FieldDefault.ValidationError = "Default version: host must be Windows";
                    IsValid = false;
                }
                if (previousValidation != version.FieldDefault.ValidationError)
                    mustRefresh = true;

                ///////////////////
                // Name validation
                previousValidation = version.FieldVersionName.ValidationError;
                version.FieldVersionName.ValidationError = null;
                if (string.IsNullOrEmpty(version.VersionName)) {
                    version.FieldVersionName.ValidationError = "Name cannot be empty";
                    IsValid = false;
                } else if (Versions
                    .Where(otherVersion => otherVersion != version
                        && otherVersion.VersionName == version.VersionName)
                    .Any()) {
                    version.FieldVersionName.ValidationError = "Duplicate version names";
                    IsValid = false;
                }
                if (previousValidation != version.FieldVersionName.ValidationError)
                    mustRefresh = true;

                ///////////////////
                // Host validation
                previousValidation = version.FieldHost.ValidationError;
                version.FieldHost.ValidationError = null;
                if (version.IsDefault && version.Host != BuildHost.Windows) {
                    version.FieldHost.ValidationError = "Default version: host must be Windows";
                    IsValid = false;
                }
                if (previousValidation != version.FieldHost.ValidationError)
                    mustRefresh = true;

                ///////////////////
                // Path validation
                previousValidation = version.FieldPath.ValidationError;
                version.FieldPath.ValidationError = null;
                if (string.IsNullOrEmpty(version.Path)) {
                    version.FieldPath.ValidationError = "Path cannot be empty";
                    IsValid = false;
                } else if (version.Host == BuildHost.Windows && !Directory.Exists(version.Path)) {
                    version.FieldPath.ValidationError = "Path does not exist";
                    IsValid = false;
                }
                if (previousValidation != version.FieldPath.ValidationError)
                    mustRefresh = true;

                ///////////////////////
                // Compiler validation
                previousValidation = version.FieldCompiler.ValidationError;
                version.FieldCompiler.ValidationError = null;
                if (string.IsNullOrEmpty(version.Compiler)) {
                    version.FieldCompiler.ValidationError = "Compiler cannot be empty";
                    IsValid = false;
                }
                if (previousValidation != version.FieldCompiler.ValidationError)
                    mustRefresh = true;
            }

            //////////////////////////////////////
            // Refresh versions table if required
            mustRefresh |= (wasValid != IsValid);
            if (mustRefresh) {
                // Reset bindings
                foreach (var version in Versions) {
                    foreach (var field in version.Fields.Values) {
                        field.Control = null;
                        field.Cell = null;
                    }
                }
                // Refresh UI
                DataGrid.Items.Refresh();
            }
        }

        static readonly Brush InvalidCellBackground = new DrawingBrush
        {
            TileMode = TileMode.Tile,
            Viewport = new Rect(0.0, 0.0, 10.0, 10.0),
            ViewportUnits = BrushMappingMode.Absolute,
            Viewbox = new Rect(0.0, 0.0, 10.0, 10.0),
            ViewboxUnits = BrushMappingMode.Absolute,
            Drawing = new DrawingGroup
            {
                Children = new DrawingCollection
                {
                    new GeometryDrawing
                    {
                        Brush = Brushes.Red,
                        Geometry = new RectangleGeometry(new Rect(5, 0, 5, 10))
                    }
                }
            },
            Transform = new RotateTransform
            {
                Angle = -135.0,
                CenterX = 0.5,
                CenterY = 0.5
            },
            Opacity = 0.25
        };

        void Control_Loaded(object sender, RoutedEventArgs e)
        {
            if (sender is Control control && GetBinding(control) is Row version) {
                if (version.LastRow)
                    return;

                Row.FieldNames field;
                if (string.IsNullOrEmpty(control.Name) || !control.Name.TryCast(out field))
                    return;

                var fieldBinding = version.Fields[field];
                fieldBinding.Control = control;
                fieldBinding.Cell = FindContainingCell(control);
                if (fieldBinding.Cell != null) {
                    fieldBinding.Cell.Background =
                        fieldBinding.IsValid ? Brushes.Transparent : InvalidCellBackground;
                }
                if (fieldBinding == FocusedField)
                    control.Focus();
                if (control is TextBox textBox && fieldBinding.SelectionStart >= 0)
                    textBox.Select(fieldBinding.SelectionStart, 0);
            }
        }

        void ComboBox_Loaded(object sender, RoutedEventArgs e)
        {
            if (sender is ComboBox comboBox && GetBinding(comboBox) is Row version) {
                comboBox.IsEnabled = false;
                var hosts = GetValues<string>(typeof(BuildHost));
                comboBox.ItemsSource = hosts;
                comboBox.Text = version.Host.Cast<string>();
                comboBox.SelectedIndex = (int)version.Host;
                comboBox.IsEnabled = true;
            }
            Control_Loaded(sender, e);
        }

        void Control_GotFocus(object sender, RoutedEventArgs e)
        {
            if (sender is Control control && GetBinding(control) is Row version) {
                Row.FieldNames field;
                if (string.IsNullOrEmpty(control.Name) || !control.Name.TryCast(out field))
                    return;
                var fieldBinding = version.Fields[field];
                if (fieldBinding.Control != control)
                    return;
                FocusedField = fieldBinding;
            }
        }

        void Control_LostFocus(object sender, RoutedEventArgs e)
        {
            if (sender is Control control && GetBinding(control) is Row version) {
                Row.FieldNames field;
                if (string.IsNullOrEmpty(control.Name) || !control.Name.TryCast(out field))
                    return;
                var fieldBinding = version.Fields[field];
                if (fieldBinding != FocusedField || fieldBinding.Control != control)
                    return;
                FocusedField = null;
            }
        }

        void TextBox_SelectionChanged(object sender, RoutedEventArgs e)
        {
            if (sender is TextBox textBox && GetBinding(textBox) is Row version) {
                Row.FieldNames field;
                if (string.IsNullOrEmpty(textBox.Name) || !textBox.Name.TryCast(out field))
                    return;
                var fieldBinding = version.Fields[field];
                if (fieldBinding.Control != textBox)
                    return;
                fieldBinding.SelectionStart = textBox.SelectionStart;
            }
        }

        void TextBox_TextChanged(object sender, TextChangedEventArgs e)
        {
            if (sender is TextBox textBox && GetBinding(textBox) is Row version) {
                Row.FieldNames field;
                if (string.IsNullOrEmpty(textBox.Name) || !textBox.Name.TryCast(out field))
                    return;
                var fieldBinding = version.Fields[field];
                if (fieldBinding == null
                    || fieldBinding.Control != textBox
                    || fieldBinding.Value == textBox.Text)
                    return;
                fieldBinding.SelectionStart = textBox.SelectionStart;
                fieldBinding.Value = textBox.Text;
                Validate(false);
            }
        }

        void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (sender is ComboBox comboBox && GetBinding(comboBox) is Row version) {
                if (!comboBox.IsEnabled || comboBox.SelectedIndex < 0)
                    return;
                string comboBoxValue = comboBox.Items[comboBox.SelectedIndex] as string;
                string controlName = comboBox.Name;
                Row.FieldNames field;
                if (string.IsNullOrEmpty(controlName) || !controlName.TryCast(out field))
                    return;
                var fieldBinding = version.Fields[field];
                if (fieldBinding == null
                    || fieldBinding.Control != comboBox
                    || fieldBinding.Value == comboBoxValue)
                    return;
                fieldBinding.Value = comboBoxValue;
                Validate(false);
            }
        }

        void Default_Click(object sender, RoutedEventArgs e)
        {
            if (sender is CheckBox checkBox && GetBinding(checkBox) is Row version) {
                var defaultVersion = Rows.Where(row => row.IsDefault).FirstOrDefault();
                if (defaultVersion != null)
                    defaultVersion.IsDefault = false;
                version.IsDefault = true;
                Validate(true);
            }
        }

        void Add_Click(object sender, RoutedEventArgs e)
        {
            var version = new Row()
            {
                IsDefault = !Versions.Any(),
                Host = BuildHost.Windows,
                Path = "",
                Compiler = "msvc",
                LastRow = false
            };
            Rows.Insert(Rows.Count - 1, version);
            FocusedField = version.FieldVersionName;
            Validate(true);
        }

        void Remove_Click(object sender, RoutedEventArgs e)
        {
            if (sender is Button button && GetBinding(button) is Row version) {
                Rows.Remove(version);
                if (version.IsDefault && Versions.Any())
                    Versions.First().IsDefault = true;
                Validate(true);
            }
        }

        void Explorer_Click(object sender, RoutedEventArgs e)
        {
            if (sender is Button button && GetBinding(button) is Row version) {
                var openFileDialog = new OpenFileDialog()
                {
                    AddExtension = false,
                    CheckFileExists = true,
                    CheckPathExists = true,
                    Filter = "qmake Executable|qmake.exe",
                    Title = "Qt VS Tools - Select qmake.exe"
                };
                if (openFileDialog.ShowDialog() == true) {
                    var qmakePath = openFileDialog.FileName;
                    var qmakeDir = Path.GetDirectoryName(qmakePath);
                    if (Path.GetFileName(qmakeDir)
                        .Equals("bin", StringComparison.InvariantCultureIgnoreCase)) {
                        qmakeDir = Path.GetDirectoryName(qmakeDir);
                        version.Path = qmakeDir;
                    } else {
                        version.Path = qmakePath;
                    }
                    if (string.IsNullOrEmpty(version.VersionName)) {
                        version.VersionName = string.Format("{0}_{1}",
                            Path.GetFileName(Path.GetDirectoryName(qmakeDir)),
                            Path.GetFileName(qmakeDir))
                            .Replace(" ", "_");
                    }
                    Validate(true);
                }
            }
        }

        static ImageSource GetExplorerIcon()
        {
            var pathWindowsExplorer = string.Format(@"{0}\explorer.exe",
                Environment.GetFolderPath(Environment.SpecialFolder.Windows));

            NativeAPI.SHFILEINFO shellFileInfo = new NativeAPI.SHFILEINFO();
            NativeAPI.SHGetFileInfo(pathWindowsExplorer,
                0, ref shellFileInfo, Marshal.SizeOf(shellFileInfo),
                NativeAPI.SHGFI.Icon | NativeAPI.SHGFI.SmallIcon);
            if (shellFileInfo.hIcon == IntPtr.Zero)
                return null;

            var iconImageSource = Imaging.CreateBitmapSourceFromHIcon(
                shellFileInfo.hIcon, Int32Rect.Empty,
                BitmapSizeOptions.FromEmptyOptions());

            NativeAPI.DestroyIcon(shellFileInfo.hIcon);
            return iconImageSource;
        }

        static object GetBinding(FrameworkElement control)
        {
            if (control == null
            || control.BindingGroup == null
            || control.BindingGroup.Items == null
            || control.BindingGroup.Items.Count == 0) {
                return null;
            }
            return control.BindingGroup.Items[0];
        }

        static DataGridCell FindContainingCell(DependencyObject control)
        {
            while (control != null) {
                if (control is ContentPresenter contentPresenter
                && contentPresenter.Parent is DataGridCell cell) {
                    return cell;
                }
                control = VisualTreeHelper.GetParent(control);
            }
            return null;
        }
    }
}