using System;
using System.Collections.Generic;
using System.Text;

namespace M_C_V
{
    // indirection between View and Model
    // View and Model have no implementation knowledge or each other
    // Views register an interest in NotifyHandler events via NotifyDispatcher
    // Request to change state of Model are triggered by call to IUpdate.Update
    // Controller can have state and saves result of last calculation
    // Controller provides a matching event dispatcher for each method in IViewable
    // Clear, Refresh, Enable and Disable(string message) see MCV.IViewableEvents
    // 
    public class Controller : Mortgage.IUpdate, MCV.IViewable
    {
        // Controller owns the Model
        private Model model = new Model();
        private bool isEnabled = true;  // used only in Refresh
        private string disableMessage = "";
        private Mortgage.Calculation defaultCalculation =
                        new Mortgage.Calculation(0, 0, 0, 0, Mortgage.INVALID, "");
        private Mortgage.Calculation lastCalculation;

        public Controller()
        {
            this.lastCalculation = defaultCalculation;
        }

        public Mortgage.Calculation Calculation
        {
            get { return this.lastCalculation; }
        }
           

        // implement IViewable methods, but Controller is NOT a View

        // Views should clear visible components, but NOT component state
        // allows recovery from clear using refresh and stored local state
        public bool Clear()
        {
            ClearDispatcher(this, new EventArgs());
            return true;
        }
        // clients will refresh data from LOCAL view state
        public virtual bool Refresh()
        {
            if (this.isEnabled)
            {
                RefreshDispatcher(this, new EventArgs());
                return true;
            }
            else
            {
                ClearDispatcher(this, new EventArgs());
                return false;
            }
        }
        public bool Enable()
        {
            isEnabled = true;
            EnableDispatcher(this, new EventArgs());
            return true;
        }
        public bool Disable(string message)
        {
            isEnabled = false;
            // reset this controller do not fire reset event
            this.lastCalculation = defaultCalculation;
            // controller is not a View component
            // it does not clear itself
            if (message != null)
            {
                disableMessage = message;
            }
            else
            {
                disableMessage = "";
            }
            // each _View_ should clear and reset _itself_ on disable event
            DisableDispatcher(this, new MCV.DisableEventArgs(disableMessage));
            return true;
        }
        public bool Reset()
        {
            this.lastCalculation = defaultCalculation;
            ResetDispatcher(this, new EventArgs());
            return true;
        }

        // create dispatcher to easily register interest in Notify event
        // eg. listener calls controller.NotifyDispatcher  += new Controller.NotifyHandler(FormView_OnNotifyEvent);
        // to register an interest in this event
        public event Mortgage.NotifyHandler NotifyDispatcher;

        // provide dispatcher in IViewableEvents that maps to each method in IViewable
        public event MCV.ClearHandler ClearDispatcher;
        public event MCV.DisableHandler DisableDispatcher;
        public event MCV.EnableHandler EnableDispatcher;
        public event MCV.RefreshHandler RefreshDispatcher;
        public event MCV.ResetHandler ResetDispatcher;
       

        public bool Update(Mortgage.Parameters mp)
        {
            Mortgage.Calculation mc = model.Calculate(mp);

            if (mc.IsValid() && isEnabled)
            {
                this.lastCalculation = mc;
                // fire event to all registered listeners of change im model state
                NotifyDispatcher(this, new Mortgage.MortgageEventArgs(mc));
                return true;
            }
            else return false; // do nothing if input data is invalid
        }
        // fire event to all registered listeners of lastCalculation
        protected bool InvokeNotifyDelegates()
        {
            if (this.isEnabled && lastCalculation.IsValid())
            {
                NotifyDispatcher(this, new Mortgage.MortgageEventArgs(lastCalculation));
                return true;
            }
            else
            {
                ClearDispatcher(this, new EventArgs());
                return false;
            }
        }
        public bool IsEnabled
        {
            get
            {
                return this.isEnabled;
            }
            set
            {
                this.isEnabled = value;
            }
        }
    }

}