using Microsoft.Azure.Management.AppService.Fluent;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using Tango.AzureUtils.Database;
using Tango.AzureUtils.FTP;
using Tango.BL.Entities;
using Tango.BL.Enumerations;

namespace Tango.AzureUtils.UI.Controls
{
    /// <summary>
    /// Interaction logic for WebAppPropertiesControl.xaml
    /// </summary>
    public partial class WebAppPropertiesControl : UserControl
    {
        public IWebAppBase WebApp
        {
            get { return (IWebAppBase)GetValue(WebAppProperty); }
            set { SetValue(WebAppProperty, value); }
        }
        public static readonly DependencyProperty WebAppProperty =
            DependencyProperty.Register("WebApp", typeof(IWebAppBase), typeof(WebAppPropertiesControl), new PropertyMetadata(null, (d, e) => (d as WebAppPropertiesControl).UpdateControl()));

        public String PPCVersionTag
        {
            get { return (String)GetValue(PPCVersionTagProperty); }
            set { SetValue(PPCVersionTagProperty, value); }
        }
        public static readonly DependencyProperty PPCVersionTagProperty =
            DependencyProperty.Register("PPCVersionTag", typeof(String), typeof(WebAppPropertiesControl), new PropertyMetadata(null, (d, e) => (d as WebAppPropertiesControl).UpdateControl()));

        public String EurekaVersionTag
        {
            get { return (String)GetValue(EurekaVersionTagProperty); }
            set { SetValue(EurekaVersionTagProperty, value); }
        }
        public static readonly DependencyProperty EurekaVersionTagProperty =
            DependencyProperty.Register("EurekaVersionTag", typeof(String), typeof(WebAppPropertiesControl), new PropertyMetadata(null, (d, e) => (d as WebAppPropertiesControl).UpdateControl()));

        public String X1VersionTag
        {
            get { return (String)GetValue(X1VersionTagProperty); }
            set { SetValue(X1VersionTagProperty, value); }
        }
        public static readonly DependencyProperty X1VersionTagProperty =
            DependencyProperty.Register("X1VersionTag", typeof(String), typeof(WebAppPropertiesControl), new PropertyMetadata(null, (d, e) => (d as WebAppPropertiesControl).UpdateControl()));

        public MachineServiceSettings Settings
        {
            get { return (MachineServiceSettings)GetValue(SettingsProperty); }
            set { SetValue(SettingsProperty, value); }
        }
        public static readonly DependencyProperty SettingsProperty =
            DependencyProperty.Register("Settings", typeof(MachineServiceSettings), typeof(WebAppPropertiesControl), new PropertyMetadata(null));

        public List<String> HostNames
        {
            get { return (List<String>)GetValue(HostNamesProperty); }
            set { SetValue(HostNamesProperty, value); }
        }
        public static readonly DependencyProperty HostNamesProperty =
            DependencyProperty.Register("HostNames", typeof(List<String>), typeof(WebAppPropertiesControl), new PropertyMetadata(null));

        public TangoVersion TangoVersion
        {
            get { return (TangoVersion)GetValue(TangoVersionProperty); }
            set { SetValue(TangoVersionProperty, value); }
        }
        public static readonly DependencyProperty TangoVersionProperty =
            DependencyProperty.Register("TangoVersion", typeof(TangoVersion), typeof(WebAppPropertiesControl), new PropertyMetadata(null));

        public TangoVersion EurekaVersion
        {
            get { return (TangoVersion)GetValue(EurekaVersionProperty); }
            set { SetValue(EurekaVersionProperty, value); }
        }
        public static readonly DependencyProperty EurekaVersionProperty =
            DependencyProperty.Register("EurekaVersion", typeof(TangoVersion), typeof(WebAppPropertiesControl), new PropertyMetadata(null));



        public TangoVersion X1Version
        {
            get { return (TangoVersion)GetValue(X1VersionProperty); }
            set { SetValue(X1VersionProperty, value); }
        }
        public static readonly DependencyProperty X1VersionProperty =
            DependencyProperty.Register("X1Version", typeof(TangoVersion), typeof(WebAppPropertiesControl), new PropertyMetadata(null));



        public FseVersion FseVersion
        {
            get { return (FseVersion)GetValue(FseVersionProperty); }
            set { SetValue(FseVersionProperty, value); }
        }
        public static readonly DependencyProperty FseVersionProperty =
            DependencyProperty.Register("FseVersion", typeof(FseVersion), typeof(WebAppPropertiesControl), new PropertyMetadata(null));



        public FseVersion TwineRSMVersion
        {
            get { return (FseVersion)GetValue(TwineRSMVersionProperty); }
            set { SetValue(TwineRSMVersionProperty, value); }
        }
        public static readonly DependencyProperty TwineRSMVersionProperty =
            DependencyProperty.Register("TwineRSMVersion", typeof(FseVersion), typeof(WebAppPropertiesControl), new PropertyMetadata(null));



        public MachineStudioVersion MachineStudioVersion
        {
            get { return (MachineStudioVersion)GetValue(MachineStudioVersionProperty); }
            set { SetValue(MachineStudioVersionProperty, value); }
        }
        public static readonly DependencyProperty MachineStudioVersionProperty =
            DependencyProperty.Register("MachineStudioVersion", typeof(MachineStudioVersion), typeof(WebAppPropertiesControl), new PropertyMetadata(null));

        public String MachineServiceVersion
        {
            get { return (String)GetValue(MachineServiceVersionProperty); }
            set { SetValue(MachineServiceVersionProperty, value); }
        }
        public static readonly DependencyProperty MachineServiceVersionProperty =
            DependencyProperty.Register("MachineServiceVersion", typeof(String), typeof(WebAppPropertiesControl), new PropertyMetadata(null));



        public bool IsBusy
        {
            get { return (bool)GetValue(IsBusyProperty); }
            set { SetValue(IsBusyProperty, value); }
        }
        public static readonly DependencyProperty IsBusyProperty =
            DependencyProperty.Register("IsBusy", typeof(bool), typeof(WebAppPropertiesControl), new PropertyMetadata(false));

        public WebAppPropertiesControl()
        {
            InitializeComponent();
        }

        private void WebAppPropertiesControl_DataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            UpdateControl();
        }

        private async void UpdateControl()
        {
            if (WebApp != null && WebApp is IWebAppBase)
            {
                IWebAppBase app = WebApp as IWebAppBase;

                try
                {
                    IsBusy = true;



                    TangoVersion = null;
                    EurekaVersion = null;
                    X1Version = null;
                    MachineStudioVersion = null;
                    FseVersion = null;
                    TwineRSMVersion = null;
                    MachineServiceVersion = null;

                    HostNames = app.HostNames.Select(x => x).ToList();

                    Settings = await app.GetMachineServiceSettingsAsync(false);

                    var azure = await AzureUtilsAuthenticationFactory.AuthenticateOrGetAsync();
                    var databaseManager = new DatabaseManager(azure);

                    if (app != WebApp) return;

                    //PPC
                    try
                    {
                        TangoVersion = await databaseManager.GetLatestTangoVersion(app, MachineTypes.TS1800, PPCVersionTag);
                    }
                    catch (Exception ex)
                    {
                        ShowError(app, ex.Message);
                    }

                    if (app != WebApp) return;

                    //Twine X4
                    try
                    {
                        EurekaVersion = await databaseManager.GetLatestTangoVersion(app, MachineTypes.Eureka, EurekaVersionTag);
                    }
                    catch (Exception ex)
                    {
                        ShowError(app, ex.Message);
                    }

                    if (app != WebApp) return;

                    //Twine X1
                    try
                    {
                        X1Version = await databaseManager.GetLatestTangoVersion(app, MachineTypes.X1, X1VersionTag);
                    }
                    catch (Exception ex)
                    {
                        ShowError(app, ex.Message);
                    }

                    if (app != WebApp) return;

                    //Machine Studio
                    try
                    {
                        MachineStudioVersion = await databaseManager.GetLatestMachineStudioVersion(app);
                    }
                    catch (Exception ex)
                    {
                        ShowError(app, ex.Message);
                    }

                    if (app != WebApp) return;

                    //FSE
                    try
                    {
                        FseVersion = await databaseManager.GetLatestFSEVersion(app, FSEBuildVariants.FSE);
                    }
                    catch (Exception ex)
                    {
                        ShowError(app, ex.Message);
                    }

                    if (app != WebApp) return;

                    //Twine Studio
                    try
                    {
                        TwineRSMVersion = await databaseManager.GetLatestFSEVersion(app, FSEBuildVariants.TwineRSM);
                    }
                    catch (Exception ex)
                    {
                        ShowError(app, ex.Message);
                    }

                    if (app != WebApp) return;

                    //Machine Service
                    try
                    {
                        FtpManager ftpManager = new FtpManager(azure);
                        MachineServiceVersion = await ftpManager.GetMachineServiceVersion(app);
                    }
                    catch (Exception ex)
                    {
                        ShowError(app, ex.Message);
                    }
                }
                catch (Exception ex)
                {
                    ShowError(app, ex.Message);
                }
                finally
                {
                    IsBusy = false;
                }
            }
        }

        private void ShowError(IWebAppBase app, String error)
        {
            MessageBox.Show(Application.Current.MainWindow, error, app.Name, MessageBoxButton.OK, MessageBoxImage.Warning);
        }
    }
}