/* Copyright (c) Citrix Systems Inc. 
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, 
 * with or without modification, are permitted provided 
 * that the following conditions are met: 
 * 
 * *   Redistributions of source code must retain the above 
 *     copyright notice, this list of conditions and the 
 *     following disclaimer. 
 * *   Redistributions in binary form must reproduce the above 
 *     copyright notice, this list of conditions and the 
 *     following disclaimer in the documentation and/or other 
 *     materials provided with the distribution. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
 * SUCH DAMAGE.
 */

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Threading;
using System.Windows.Forms;
using XenAdmin.Actions;
using XenAdmin.Controls;
using XenAdmin.Core;
using XenAdmin.Diagnostics.Checks;
using XenAdmin.Diagnostics.Checks.DR;
using XenAdmin.Diagnostics.Problems;
using XenAdmin.Dialogs;
using XenAdmin.Properties;
using XenAPI;

using XenAdmin.Actions.DR;

namespace XenAdmin.Wizards.DRWizards
{
    public partial class DRFailoverWizardPrecheckPage : XenTabPage
    {
        private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        public event Action<string> NewDrTaskIntroduced;
        public event Action<XenRef<SR>> SrIntroduced;

        private Pool _pool;
        public Pool Pool { set { _pool = value; } }

        private Dictionary<XenRef<VDI>, PoolMetadata> selectedPoolMetadata;
        public Dictionary<XenRef<VDI>, PoolMetadata> SelectedPoolMetadata {set { selectedPoolMetadata = value; }}

        public List<AsyncAction> RevertActions = new List<AsyncAction>();

        private string _nextButtonText = Messages.WIZARD_BUTTON_NEXT;
        
        public override string NextText(bool isLastPage)
        {
            return _nextButtonText;
        }

        public DRFailoverWizardPrecheckPage()
        {
            InitializeComponent();
            dataGridView1.BackgroundColor = dataGridView1.DefaultCellStyle.BackColor;
        }

        public override string PageTitle
        {
            get
            {
                switch (WizardType)
                {
                    case DRWizardType.Failback:
                        return Messages.DR_WIZARD_PRECHECKPAGE_TITLE_FAILBACK;
                    default:
                        return Messages.DR_WIZARD_PRECHECKPAGE_TITLE_FAILOVER;
                } 
            }
        }

        public override string Text
        {
            get
            {
                return Messages.DR_WIZARD_PRECHECKPAGE_TEXT;
            }
        }

        public override string HelpID
        {
            get 
            {
                switch (WizardType)
                {
                    case DRWizardType.Failback:
                        return "Failback_Prechecks";
                    case DRWizardType.Dryrun:
                        return "Dryrun_Prechecks";
                    default:
                        return "Failover_Prechecks";
                }
            }
        }

        public override bool EnablePrevious()
        {
            return _worker != null && !_worker.IsBusy;
        }

        private int PercentageSelectedObjects(int i)
        {
            int count = 0;
            foreach (var poolMetadata in selectedPoolMetadata.Values)
            {
                count += (poolMetadata.VmAppliances.Count + poolMetadata.Vms.Count);
            }
            return (int)(((float)i / (float)(count)) * 100);
        }

        private BackgroundWorker _worker = null;
        public override void PageLoaded(PageLoadedDirection direction)
        {
            base.PageLoaded(direction);
            SetupLabels();

            try
            {
                if (direction == PageLoadedDirection.Back)
                    return;

                RefreshRechecks();
            }
            catch (Exception e)
            {
                log.Error(e, e);
                throw;//better throw an exception rather than closing the wizard suddenly and silently
            }
        }

        public DRWizardType WizardType { private get; set; }

        private void SetupLabels()
        {
            switch (WizardType)
            {
                case DRWizardType.Failback:
                    labelContinue.Text = Messages.DR_WIZARD_PRECHECKPAGE_CONTINUE_FAILBACK;
                    _nextButtonText = Messages.DR_WIZARD_PRECHECKPAGE_NEXT_FAILBACK;
                    break;
                case DRWizardType.Dryrun:
                    labelContinue.Text = Messages.DR_WIZARD_PRECHECKPAGE_CONTINUE_DRYRUN;
                    _nextButtonText = Messages.DR_WIZARD_PRECHECKPAGE_NEXT_FAILOVER;
                    break;
                default:
                    labelContinue.Text = Messages.DR_WIZARD_PRECHECKPAGE_CONTINUE_FAILOVER;
                    _nextButtonText = Messages.DR_WIZARD_PRECHECKPAGE_NEXT_FAILOVER;
                    break;
            } 
        }

        protected void RefreshRechecks()
        {
            buttonResolveAll.Enabled = buttonReCheckProblems.Enabled = false;
            _worker = null;
            _worker = new BackgroundWorker();
            _worker.DoWork += new DoWorkEventHandler(worker_DoWork);
            _worker.WorkerReportsProgress = true;
            _worker.WorkerSupportsCancellation = true;
            _worker.ProgressChanged += new ProgressChangedEventHandler(worker_ProgressChanged);
            _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_worker_RunWorkerCompleted);
            _worker.RunWorkerAsync();
        }

        void _worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (!e.Cancelled)
                OnPageUpdated();
            progressBar1.Value = 100;
            bool problemsFound = false;
            foreach (PreCheckGridRow row in dataGridView1.Rows)
            {
                PreCheckItemRow preCheckRow = row as PreCheckItemRow;
                if (preCheckRow != null && preCheckRow.Problem != null)
                {
                    problemsFound = true;
                    break;
                }
            }
            buttonResolveAll.Enabled = problemsFound;
            buttonReCheckProblems.Enabled = true;
        }

        void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            try
            {
                var row = e.UserState as DataGridViewRow;
                if (row != null && !dataGridView1.Rows.Contains(row))
                {
                    PreCheckItemRow preCheckRow = row as PreCheckItemRow;
                    if (preCheckRow != null && preCheckRow.IsProblem)
                        preCheckRow.Visible = true;
                    else
                        row.Visible = !checkBoxViewPrecheckFailuresOnly.Checked;
                    dataGridView1.Rows.Add(row);
                }

                int step = (int)((1.0 / ((float)_numberChecks)) * e.ProgressPercentage);
                progressBar1.Value += (step + progressBar1.Value) > 100 ? 0 : step;
            }
            catch (Exception) { }
        }

        private DataGridViewRow ExecuteCheck(Check check)
        {
            Problem problem = check.RunCheck();
            if (problem != null)
            {
                return new PreCheckItemRow(problem);
            } 
            return new PreCheckItemRow(check);
        }

        private int _numberChecks = 0;
        private readonly object _lock = new object();
        void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            lock (_lock)
            {
                Program.Invoke(this, () =>
                                         {
                                             dataGridView1.Rows.Clear();
                                             progressBar1.Value = 0;
                                         });

                RevertActions.Clear();
                List<KeyValuePair<string, List<Check>>> checks = GenerateChecks();
                _numberChecks = checks.Count;
                for (int i = 0; i < checks.Count; i++)
                {
                    List<Check> checkGroup = checks[i].Value;
                    DataGridViewRow row =
                        new PreCheckHeaderRow(string.Format(Messages.DR_WIZARD_PRECHECKPAGE_HEADER, i + 1,
                                                            checks.Count, checks[i].Key));
                    _worker.ReportProgress(5, row);

                    Session metadataSession = null;

                    // execute checks
                    for (int j = 0; j < checkGroup.Count; j++)
                    {
                        if (_worker.CancellationPending)
                        {
                            e.Cancel = true;
                            return;
                        }
                        Check check = checkGroup[j];

                        // special case - AssertCanBeRecoveredCheck - we need to open the metadata database
                        if (check is AssertCanBeRecoveredCheck)
                        {
                            AssertCanBeRecoveredCheck thisCheck = check as AssertCanBeRecoveredCheck;
                            AssertCanBeRecoveredCheck prevCheck = j > 0
                                                                      ? checkGroup[j - 1] as
                                                                        AssertCanBeRecoveredCheck
                                                                      : null;
                            if (prevCheck == null || prevCheck.Vdi.uuid != thisCheck.Vdi.uuid)
                            {
                                // close previous metadata session
                                if (metadataSession != null)
                                    metadataSession.logout();

                                // open metadata database
                                VdiOpenDatabaseAction action = new VdiOpenDatabaseAction(Connection,
                                                                                         ((AssertCanBeRecoveredCheck
                                                                                          )checkGroup[0]).Vdi);
                                action.RunExternal(action.Session);
                                if (action.Succeeded && action.MetadataSession != null)
                                    metadataSession = action.MetadataSession;
                            }

                            // run check
                            if (metadataSession != null)
                            {
                                thisCheck.MetadataSession = metadataSession;
                                row = ExecuteCheck(thisCheck);
                                _worker.ReportProgress(PercentageSelectedObjects(j + 1), row);

                                // close metadata session if this is the last check
                                if (j == checkGroup.Count - 1)
                                    metadataSession.logout();
                            }
                        }
                        else
                        {
                            row = ExecuteCheck(check);
                            _worker.ReportProgress(PercentageSelectedObjects(j + 1), row);
                        }
                    }
                }
            }
        }

        private List<KeyValuePair<string, List<Check>>> GenerateChecks()
        {
            List<KeyValuePair<string, List<Check>>> checks = new List<KeyValuePair<string, List<Check>>>();
            List<Check> checkGroup;

            //HA checks
            if (WizardType == DRWizardType.Dryrun)
            {
                checks.Add(new KeyValuePair<string, List<Check>>(Messages.DR_WIZARD_CHECKING_HA_STATUS,
                                                                 new List<Check>()));
                checkGroup = checks[checks.Count - 1].Value;
                checkGroup.Add(new DrHAEnabledCheck(_pool));
            }

            // check if selected VMs and appliances are still running in the source pool
            if (WizardType != DRWizardType.Dryrun)
            {
                checkGroup = new List<Check>();
                foreach (PoolMetadata poolMetadata in selectedPoolMetadata.Values)
                {
                    // is source pool connected?
                    PoolMetadata metadata = poolMetadata;
                    Pool sourcePool = ConnectionsManager.XenConnectionsCopy.Select
                        (connection => Helpers.GetPoolOfOne(connection)).FirstOrDefault
                        (pool => pool != null && pool.uuid == metadata.Pool.uuid);
                    if (sourcePool != null)
                    {
                        foreach (VM_appliance vmAppliance in poolMetadata.VmAppliances.Values)
                        {
                            checkGroup.Add(new RunningVmApplianceCheck(vmAppliance, sourcePool));
                        }
                        
                        foreach (VM vm in poolMetadata.Vms.Values)
                        {
                            if (vm.appliance.opaque_ref != null && vm.appliance.opaque_ref.StartsWith("OpaqueRef:") &&
                                vm.appliance.opaque_ref != "OpaqueRef:NULL")
                            {
                                //VM included in an appliance
                                continue;
                            }
                            checkGroup.Add(new RunningVmCheck(vm, sourcePool));
                        }
                    }
                }
                if (checkGroup.Count > 0)
                    checks.Add(
                        new KeyValuePair<string, List<Check>>(
                            Messages.DR_WIZARD_CHECKING_POWER_STATE_IN_SOURCE_POOLS, checkGroup));
            }

            //Existing VMs and appliances checks
            checkGroup = new List<Check>();
            foreach (PoolMetadata poolMetadata in selectedPoolMetadata.Values)
            {
                foreach (VM_appliance vmAppliance in poolMetadata.VmAppliances.Values)
                {
                    PoolMetadata metadata = poolMetadata;
                    List<VM> vms = (from vmRef in vmAppliance.VMs
                                    where metadata.Vms.ContainsKey(vmRef)
                                    select metadata.Vms[vmRef]).ToList();
                    checkGroup.Add(new ExistingVmApplianceCheck(vmAppliance, vms, _pool));
                }
                
                foreach (VM vm in poolMetadata.Vms.Values)
                {
                    if (vm.appliance.opaque_ref != null && vm.appliance.opaque_ref.StartsWith("OpaqueRef:") &&
                                vm.appliance.opaque_ref != "OpaqueRef:NULL")
                    {
                        //VM included in an appliance
                        continue;
                    }
                    checkGroup.Add(new ExistingVmCheck(vm, _pool));
                }
            }
            if (checkGroup.Count > 0)
                checks.Add(new KeyValuePair<string, List<Check>>(String.Format(Messages.DR_WIZARD_CHECKING_EXISTING_APPLIANCES_AND_VMS, _pool.Name), checkGroup));

        
            //VM and appliance can be recovered checks
            checks.Add(new KeyValuePair<string, List<Check>>(String.Format(Messages.DR_WIZARD_CHECKING_VMS_CAN_BE_RECOVERED, _pool.Name), new List<Check>()));
            checkGroup = checks[checks.Count - 1].Value;
            foreach (PoolMetadata poolMetadata in selectedPoolMetadata.Values)
            {
                foreach (VM_appliance vmAppliance in poolMetadata.VmAppliances.Values)
                {
                    checkGroup.Add(new AssertCanBeRecoveredCheck(vmAppliance, _pool, poolMetadata.Vdi));
                }    
                
                foreach (VM vm in poolMetadata.Vms.Values)
                {
                    if (vm.appliance.opaque_ref != null && vm.appliance.opaque_ref.StartsWith("OpaqueRef:") && vm.appliance.opaque_ref != "OpaqueRef:NULL")
                    {
                        //VM included in an appliance
                        continue;
                    }
                    checkGroup.Add(new AssertCanBeRecoveredCheck(vm, _pool, poolMetadata.Vdi));
                }
            }
            return checks;
        }

        public override void PageLeave(PageLoadedDirection direction, ref bool cancel)
        {
            if (direction == PageLoadedDirection.Back)
            {
                _worker.CancelAsync();
                _worker = null;
            }
            base.PageLeave(direction, ref cancel);
        }

        public override bool EnableNext()
        {
            int problemsCount = 0;
            foreach (DataGridViewRow row in dataGridView1.Rows)
            {
                PreCheckItemRow preCheckRow = row as PreCheckItemRow;
                if (preCheckRow != null && preCheckRow.IsProblem)
                {
                    problemsCount++;
                }

            }

            if (_worker != null && _worker.IsBusy)
                labelPrecheckStatus.Text = Messages.DR_WIZARD_PRECHECKPAGE_STATUS_RUNNING;
            else
            {
                labelPrecheckStatus.Text = problemsCount > 0
                                               ? string.Format(Messages.DR_WIZARD_PRECHECKPAGE_STATUS_FAILURE, problemsCount)
                                               : Messages.DR_WIZARD_PRECHECKPAGE_STATUS_SUCCESS;
            }

            bool result = _worker != null && !_worker.IsBusy && problemsCount==0;
            panelErrorsFound.Visible = !result;
            labelContinue.Visible = result;

            return result;
        }

        public override void PageCancelled()
        {
            if (_worker != null)
                _worker.CancelAsync();
        }

        internal List<string> GetWarnings()
        {
            var warnings = new List<string>();
            foreach (DataGridViewRow row in dataGridView1.Rows)
            {
                var preCheckRow = row as PreCheckItemRow;
                if (preCheckRow != null && preCheckRow.IsWarning)
                {
                    warnings.Add(preCheckRow.Description);
                }
            }
            return warnings;
        }

        private ActionProgressDialog _progressDialog = null;

        private void ExecuteSolution(PreCheckItemRow preCheckRow)
        {
            bool cancelled;
            AsyncAction action = preCheckRow.Problem.SolveImmediately(out cancelled);
            if (action != null)
            {
                action.Completed += action_Completed;
                _progressDialog = new ActionProgressDialog(action, ProgressBarStyle.Blocks);
                _progressDialog.ShowDialog(this);
                if (action.Succeeded)
                {
                    var revertAction = preCheckRow.Problem.UnwindChanges();
                    if (revertAction != null)
                        RevertActions.Add(revertAction);
                }
            }
        }
        
        private void action_Completed(object sender, EventArgs e)
        {
            Thread.Sleep(1000);
            Program.Invoke(Program.MainWindow, RefreshRechecks);

            var drTaskCreateAction = sender as DrTaskCreateAction;
            if (drTaskCreateAction != null && drTaskCreateAction.Succeeded)
            {
                if (NewDrTaskIntroduced != null)
                    NewDrTaskIntroduced(drTaskCreateAction.Result);
                return;
            }

            var srIntroduceAction = sender as SrIntroduceAction;
            if (srIntroduceAction != null && srIntroduceAction.Succeeded)
            {
                if (SrIntroduced != null)
                    SrIntroduced(new XenRef<SR>(srIntroduceAction.Result));
            }
        }

        private void buttonReCheckProblems_Click(object sender, EventArgs e)
        {
            RefreshRechecks();
        }

        private void buttonResolveAll_Click(object sender, EventArgs e)
        {
            Dictionary<AsyncAction, AsyncAction> actions = new Dictionary<AsyncAction, AsyncAction>();
            foreach (DataGridViewRow row in dataGridView1.Rows)
            {
                PreCheckItemRow preCheckRow = row as PreCheckItemRow;
                if (preCheckRow != null && preCheckRow.Problem != null)
                {
                    bool cancelled;
                    AsyncAction action = preCheckRow.Problem.SolveImmediately(out cancelled);
                    if (action != null)
                    {
                        actions.Add(action, preCheckRow.Problem.UnwindChanges());
                    }
                }
            }
            foreach (var asyncAction in actions.Keys)
            {
                _progressDialog = new ActionProgressDialog(asyncAction, ProgressBarStyle.Blocks);
                _progressDialog.ShowDialog(this);

                if (asyncAction.Succeeded && actions[asyncAction] != null)
                    RevertActions.Add(actions[asyncAction]);
                Program.Invoke(Program.MainWindow, RefreshRechecks);
            }
            Program.Invoke(Program.MainWindow, RefreshRechecks);
        }

        private void checkBoxViewPrecheckFailuresOnly_CheckedChanged(object sender, EventArgs e)
        {
            //RefreshRechecks();
            foreach (DataGridViewRow row in dataGridView1.Rows)
            {
                var preCheckRow = row as PreCheckItemRow;
                if (preCheckRow != null && preCheckRow.IsProblem)
                    preCheckRow.Visible = true;
                else
                    row.Visible = !checkBoxViewPrecheckFailuresOnly.Checked;
            }
        }

        private void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {
            PreCheckItemRow preChecRow = dataGridView1.Rows[e.RowIndex] as PreCheckItemRow;
            if (preChecRow != null && e.ColumnIndex == 2)
            {
                ExecuteSolution(preChecRow);
                return;
            }
        } 

        #region PreCheckGridRow
        private abstract class PreCheckGridRow : DataGridViewRow
        {           
            protected DataGridViewImageCell _iconCell = new DataGridViewImageCell();
            protected DataGridViewTextBoxCell _descriptionCell = new DataGridViewTextBoxCell();
            protected DataGridViewCell _solutionCell = new DataGridViewLinkCell();

            protected PreCheckGridRow()
            {
                Cells.Add(_iconCell);
                Cells.Add(_descriptionCell);
                Cells.Add(_solutionCell);
            }
        }

        private class PreCheckHeaderRow : PreCheckGridRow
        {
            public PreCheckHeaderRow(string text)
            {
                _iconCell.Value = new Bitmap(1, 1);
                _descriptionCell.Value = text;
                _descriptionCell.Style.Font = new Font(Program.DefaultFont, FontStyle.Bold);
            }
        }

        private class PreCheckItemRow : PreCheckGridRow
        {
            private Problem _problem = null;
            private Check _check = null;
            public PreCheckItemRow(Problem problem)
            {
                _problem = problem;
                _check = problem.Check;
                UpdateRowFields();
            }

            public PreCheckItemRow(Check check)
            {
                _check = check;
                UpdateRowFields();
            }

            private void UpdateRowFields()
            {
                _iconCell.Value = Problem == null
                    ? Resources._000_Tick_h32bit_16
                    : Problem is Warning ? Resources._000_Alert2_h32bit_16 : Resources._000_Abort_h32bit_16;

                if (Problem != null)
                    _descriptionCell.Value = String.Format(Messages.DR_WIZARD_PRECHECKPAGE_PROBLEM, _check.Description, Problem.Description);
                else if (_check != null)
                {
                    _descriptionCell.Value = String.Format(Messages.DR_WIZARD_PRECHECKPAGE_OK, _check.Description);
                }
                _solutionCell.Value = Problem == null ? string.Empty : Problem.HelpMessage;
            }

            public Problem Problem
            {
                get
                {
                    return _problem;
                }
            }

            public string Description
            {
                get
                {
                    return _descriptionCell.Value as string;
                }
            }

            public bool IsProblem
            {
                get { return _problem != null && !(_problem is Warning); }
            }

            public bool IsWarning
            {
                get { return _problem != null && _problem is Warning; }
            }

            public override bool Equals(object obj)
            {
                PreCheckItemRow other = obj as PreCheckItemRow;
                if (other != null && other.Problem != null && _problem != null)
                    return _problem.CompareTo(other.Problem) == 0;
                return false;
            }

            public override int GetHashCode()
            {
                return (_problem != null ? _problem.GetHashCode() : 0);
            }
        }
        #endregion
    }

}