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

using System;
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;

namespace QtVsTools.Options
{
    using Common;
    using QtVsTools.Core;
    using static Common.EnumExt;

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

    public partial class QtVersionsTable : UserControl
    {
        LazyFactory Lazy { get; } = new LazyFactory();

        public QtVersionsTable()
        {
            InitializeComponent();
        }

        [Flags] public enum Column
        {
            IsDefault = 0x10,
            VersionName = 0x20,
            Host = 0x40,
            Path = 0x80,
            Compiler = 0x100
        }

        [Flags] public enum State
        {
            Unknown = 0x00,
            Existing = 0x01,
            Removed = 0x02,
            Modified = 0x04
        }

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

        public class Row
        {
            static LazyFactory StaticLazy { get; } = new LazyFactory();
            LazyFactory Lazy { get; } = new LazyFactory();

            public Dictionary<Column, Field> Fields => Lazy.Get(() =>
                Fields, () => GetValues<Column>()
                    .Select(field => new KeyValuePair<Column, Field>(field, null))
                    .ToDictionary(keyValue => keyValue.Key, keyValue => keyValue.Value));

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

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

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

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

            public Field FieldCompiler => Fields[Column.Compiler]
                ?? (Fields[Column.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 RowContentVisibility
                => 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 => StaticLazy.Get(() =>
                ExplorerIcon, () => GetExplorerIcon());

            public State State { get; set; } = State.Unknown;
            public bool RowVisible => State != State.Removed;
        }

        Field FocusedField { get; set; }

        List<Row> Rows => Lazy.Get(() => 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;
            FocusedField = null;
            Validate(true);
            Rows.ForEach(item => item.State = State.Existing);
        }

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

        void Validate(bool mustRefresh)
        {
            ////////////////////////
            // Validate cell values
            foreach (var version in Versions) {
                if (!version.State.HasFlag(State.Modified))
                    continue;

                //////////////////////
                // Default validation
                if (version.State.HasFlag((State)Column.IsDefault)) {
                    version.FieldDefault.ValidationError = null;
                    if (version.IsDefault && version.Host != BuildHost.Windows)
                        version.FieldDefault.ValidationError = "Default version: Host must be Windows";
                    mustRefresh |= version.FieldDefault.UpdateUi;
                }

                ///////////////////
                // Name validation
                if (version.State.HasFlag((State)Column.VersionName)) {
                    version.FieldVersionName.ValidationError = null;
                    if (string.IsNullOrEmpty(version.VersionName)) {
                        version.FieldVersionName.ValidationError = "Name cannot be empty";
                    } else if (Versions.Where(otherVersion => otherVersion != version
                        && otherVersion.VersionName == version.VersionName).Any()) {
                        version.FieldVersionName.ValidationError = "Duplicate version names";
                    }
                    mustRefresh |= version.FieldVersionName.UpdateUi;
                }

                ///////////////////
                // Host validation
                if (version.State.HasFlag((State)Column.Host)) {
                    version.FieldHost.ValidationError = null;
                    if (version.IsDefault && version.Host != BuildHost.Windows)
                        version.FieldHost.ValidationError = "Default version: Host must be Windows";
                    mustRefresh |= version.FieldHost.UpdateUi;
                }

                ///////////////////
                // Path validation
                if (version.State.HasFlag((State)Column.Path)) {
                    version.FieldPath.ValidationError = null;
                    if (string.IsNullOrEmpty(version.Path)) {
                        version.FieldPath.ValidationError = "Path cannot be empty";
                    } else if (version.Host == BuildHost.Windows) {
                        string path = NormalizePath(version.Path);
                        if (path == null) {
                            version.FieldPath.ValidationError = "Invalid path format";
                        } else {
                            if (!QMake.Exists(path))
                                version.FieldPath.ValidationError = "Cannot find qmake.exe";
                        }
                    }
                    mustRefresh |= version.FieldPath.UpdateUi;
                }

                ///////////////////////
                // Compiler validation
                if (version.State.HasFlag((State)Column.Compiler)) {
                    version.FieldCompiler.ValidationError = null;
                    if (string.IsNullOrEmpty(version.Compiler))
                        version.FieldCompiler.ValidationError = "Compiler cannot be empty";
                    mustRefresh |= version.FieldCompiler.UpdateUi;
                }
            }

            //////////////////////////////////////
            // Refresh versions table if required
            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;
                if (string.IsNullOrEmpty(control.Name) || !control.Name.TryCast(out Column column))
                    return;

                var field = version.Fields[column];
                field.Control = control;
                field.Cell = FindContainingCell(control);
                if (field.Cell != null) {
                    field.Cell.Background =
                        field.IsValid ? Brushes.Transparent : InvalidCellBackground;
                }
                if (field == FocusedField)
                    control.Focus();
                if (control is TextBox textBox && field.SelectionStart >= 0)
                    textBox.Select(field.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) {
                if (string.IsNullOrEmpty(control.Name) || !control.Name.TryCast(out Column column))
                    return;

                var field = version.Fields[column];
                if (field.Control != control)
                    return;
                FocusedField = field;
            }
        }

        void Control_LostFocus(object sender, RoutedEventArgs e)
        {
            if (sender is Control control && GetBinding(control) is Row version) {
                if (string.IsNullOrEmpty(control.Name) || !control.Name.TryCast(out Column column))
                    return;

                var field = version.Fields[column];
                if (field != FocusedField || field.Control != control)
                    return;
                FocusedField = null;
            }
        }

        void TextBox_SelectionChanged(object sender, RoutedEventArgs e)
        {
            if (sender is TextBox textBox && GetBinding(textBox) is Row version) {
                if (string.IsNullOrEmpty(textBox.Name) || !textBox.Name.TryCast(out Column column))
                    return;

                var field = version.Fields[column];
                if (field.Control != textBox)
                    return;
                field.SelectionStart = textBox.SelectionStart;
            }
        }

        void TextBox_TextChanged(object sender, TextChangedEventArgs e)
        {
            if (sender is TextBox textBox && GetBinding(textBox) is Row version) {
                if (string.IsNullOrEmpty(textBox.Name) || !textBox.Name.TryCast(out Column column))
                    return;

                var field = version.Fields[column];
                if (field == null
                    || field.Control != textBox
                    || field.Value == textBox.Text)
                    return;

                field.SelectionStart = textBox.SelectionStart;
                field.Value = textBox.Text;
                version.State |= State.Modified | (State)column;

                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;
                if (string.IsNullOrEmpty(comboBox.Name) || !comboBox.Name.TryCast(out Column column))
                    return;

                string comboBoxValue = comboBox.Items[comboBox.SelectedIndex] as string;
                var field = version.Fields[column];
                if (field == null
                    || field.Control != comboBox
                    || field.Value == comboBoxValue)
                    return;

                field.Value = comboBoxValue;
                version.State |= State.Modified | (State)Column.Host;

                bool mustRefresh = false;
                if (version.Host != BuildHost.Windows && version.Compiler == "msvc") {
                    version.Compiler = "g++";
                    version.FieldCompiler.SelectionStart = version.Compiler.Length;
                    version.State |= (State)Column.Compiler;
                    mustRefresh = true;
                } else if (version.Host == BuildHost.Windows && version.Compiler != "msvc") {
                    version.Compiler = "msvc";
                    version.FieldCompiler.SelectionStart = version.Compiler.Length;
                    version.State |= (State)Column.Compiler;
                    mustRefresh = true;
                }

                Validate(mustRefresh);
            }
        }

        static void SetDefaultState(ref Row version, bool value)
        {
            version.IsDefault = value;
            version.State |= State.Modified | (State)Column.IsDefault;
        }

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

        void Add_Click(object sender, RoutedEventArgs e)
        {
            var version = new Row()
            {
                IsDefault = !Versions.Any(x => x.State != State.Removed),
                Host = BuildHost.Windows,
                Path = "",
                Compiler = "msvc",
                LastRow = false,
                State = State.Modified | (State)Column.VersionName | (State)Column.Host
                                       | (State)Column.Path | (State)Column.Compiler
            };
            if (version.IsDefault)
                version.State |= (State)Column.IsDefault;
            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) {
                version.State = State.Removed;
                if (version.IsDefault) {
                    var first = Versions.FirstOrDefault(x => x.State != State.Removed);
                    if (first != null)
                        SetDefaultState(ref first, true);
                }
                Validate(true);
            }
        }

        static string NormalizePath(string path)
        {
            if (string.IsNullOrEmpty(path))
                return path;
            try {
                return Path.GetFullPath(new Uri(path).LocalPath)
                    .TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
                    .ToUpperInvariant();
            } catch (UriFormatException) {
                return null;
            }
        }

        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);
                    var previousPath = NormalizePath(version.Path);
                    if (Path.GetFileName(qmakeDir)
                        .Equals("bin", StringComparison.InvariantCultureIgnoreCase)) {
                        qmakeDir = Path.GetDirectoryName(qmakeDir);
                        version.Path = qmakeDir;
                    } else {
                        version.Path = qmakePath;
                    }

                    if (previousPath != NormalizePath(version.Path))
                        version.State |= State.Modified | (State)Column.Path;

                    if (string.IsNullOrEmpty(version.VersionName)) {
                        version.VersionName = string.Format("{0}_{1}",
                            Path.GetFileName(Path.GetDirectoryName(qmakeDir)),
                            Path.GetFileName(qmakeDir))
                            .Replace(" ", "_");
                        version.State |= State.Modified | (State)Column.VersionName;
                    }

                    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;
        }
    }
}