C.B.R.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CBR.Core.Helpers;
using CBR.Core.Models;
using CBR.Core.Services;
using System.Windows.Input;
using System.Windows.Threading;
using CBR.Core.Files;
using CBR.Components;

namespace CBR.ViewModels
{
	public class BookViewModelBase : ViewModelBase
	{
		#region ----------------CONSTRUCTOR----------------

		public BookViewModelBase(Book bk)
		{
			if (bk != null)
			{
                Service = BookServiceFactory.Instance.GetService(bk);

                Data = bk;
                //BookData.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_bookData_PropertyChanged);
			}

            //register to the mediator for messages
            Mediator.Instance.RegisterHandler( ViewModelMessages.SettingsChanged, 
                (Object o) =>
                {
                    RaisePropertyChanged("MagnifierSize");
                    RaisePropertyChanged("MagnifierScale");
                } );

            //create a dispatch timer to load the image cache
            _CacheTimerClock = new DispatcherTimer();
            _CacheTimerClock.Interval = new TimeSpan(0, 0, 5);
            _CacheTimerClock.IsEnabled = true;
            _CacheTimerClock.Tick += new EventHandler(CacheTimerClockElapsed);
		}

		void _bookData_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
		{
			//RaisePropertyChanged(e.PropertyName);
		}

		#endregion

		#region -----------------PROPERTIES-----------------

        private DispatcherTimer _CacheTimerClock;

        public double MagnifierSize
        {
            get { return WorkspaceService.Instance.Settings.MagnifierSize; }
        }

        public double MagnifierScale
        {
            get { return WorkspaceService.Instance.Settings.MagnifierScaleFactor; }
        }

        new public Book Data
        {
            get { return base.Data as Book; }
            set { base.Data = value; }
        }

        private double _scale = 0.2;
        public double Scale
        {
            get { return _scale; }
            set
            {
                if (_scale != value)
                {
                    _scale = value;
                    RaisePropertyChanged("Scale");
                }
            }
        }

        public BookServiceBase Service { get; set; }

        public long CacheSize { get; set; }

        public string CacheInfo
        {
            get
            {
                return "No cache information";
            }
        }

        public string PageInfo
        {
            get
            {
                return string.Empty;
            }
        }

        private bool _isInEditMode = false;
        public bool IsInEditMode
        {
            get { return _isInEditMode; }
            set
            {
                if (_isInEditMode != value)
                {
                    _isInEditMode = value;
                    RaisePropertyChanged("IsInEditMode");
                }
            }
        }
        #endregion

        #region -----------------COMMANDS-----------------

        #region save command

        private ICommand bookSaveCommand;
        public ICommand BookSaveCommand
        {
            get
            {
                if (bookSaveCommand == null)
                    bookSaveCommand = new DelegateCommand(SaveCommandExecute, SaveCommandCanExecute);
                return bookSaveCommand;
            }
        }

        virtual public bool SaveCommandCanExecute()
        {
            return false;
        }

        virtual public void SaveCommandExecute()
        {
        }

        #endregion

        #region bookmark command

        private ICommand bookmarkCommand;
        public ICommand BookmarkCommand
        {
            get
            {
                if (bookmarkCommand == null)
                    bookmarkCommand = new DelegateCommand(BookmarkCommandExecute, BookmarkCommandCanExecute);
                return bookmarkCommand;
            }
        }

        virtual public bool BookmarkCommandCanExecute()
        {
            return false;
        }

        virtual public void BookmarkCommandExecute()
        {
        }

        #endregion

        #region goto bookmark command

        private ICommand gotoBookmarkCommand;
        public ICommand GotoBookmarkCommand
        {
            get
            {
                if (gotoBookmarkCommand == null)
                    gotoBookmarkCommand = new DelegateCommand(GotoBookmarkCommandExecute, GotoBookmarkCommandCanExecute);
                return gotoBookmarkCommand;
            }
        }

        virtual public bool GotoBookmarkCommandCanExecute()
        {
            return Service.HasMark(Data);
        }

        virtual public void GotoBookmarkCommandExecute()
        {
        }

        #endregion

        #region clear bookmark command

        private ICommand clearBookmarkCommand;
        public ICommand ClearBookmarkCommand
        {
            get
            {
                if (clearBookmarkCommand == null)
                    clearBookmarkCommand = new DelegateCommand(ClearBookmarkCommandExecute, ClearBookmarkCommandCanExecute);
                return clearBookmarkCommand;
            }
        }

        virtual public bool ClearBookmarkCommandCanExecute()
        {
            return Service.HasMark(Data);
        }

        virtual public void ClearBookmarkCommandExecute()
        {
            Service.ClearMark(Data);
        }

        #endregion

        #region fit mode command

        private ICommand fitModeCommand;
        public ICommand FitModeCommand
        {
            get
            {
                if (fitModeCommand == null)
                    fitModeCommand = new DelegateCommand<string>(FitModeCommandExecute, FitModeCommandCanExecute);
                return fitModeCommand;
            }
        }

        virtual public bool FitModeCommandCanExecute(string param)
        {
            return false;
        }

        virtual public void FitModeCommandExecute(string param)
        {
        }

        #endregion

        #region close command

        private ICommand bookCloseCommand;
        public ICommand BookCloseCommand
        {
            get
            {
                if (bookCloseCommand == null)
                    bookCloseCommand = new DelegateCommand(CloseCommandExecute, CloseCommandCanExecute);
                return bookCloseCommand;
            }
        }

        virtual public bool CloseCommandCanExecute()
        {
            return true;
        }

        virtual public void CloseCommandExecute()
        {
            if (Data != null)
                Service.UnloadBook(Data);
            Data = null;
        }

        #endregion

        #region change page command
        private ICommand bookChangePageCommand;
        public ICommand BookChangePageCommand
        {
            get
            {
                if (bookChangePageCommand == null)
                    bookChangePageCommand = new DelegateCommand<string>(GotoPage, CanGotoPage);
                return bookChangePageCommand;
            }
        }

        virtual public bool CanGotoPage(string step)
        {
            return false;
        }

        virtual public void GotoPage(string step)
        {
            return;

        }
        #endregion

        #region goto page command

        private ICommand bookGotoPageCommand;
        public ICommand BookGotoPageCommand
        {
            get
            {
                if (bookGotoPageCommand == null)
                    bookGotoPageCommand = new DelegateCommand<string>(GotoPageCommandExecute, GotoPageCommandCanExecute);
                return bookGotoPageCommand;
            }
        }

        virtual public bool GotoPageCommandCanExecute(string param)
        {
            if (Data != null)
                return Service.CanGotoPage(Data, Convert.ToInt32(param));
            else
                return false;
        }

        virtual public void GotoPageCommandExecute(string param)
        {
            if (Data != null)
                Service.GotoPage(Data, Convert.ToInt32(param));
        }

        #endregion

        #region goto page command

        private ICommand bookGotoLastPageCommand;
        public ICommand BookGotoLastPageCommand
        {
            get
            {
                if (bookGotoLastPageCommand == null)
                    bookGotoLastPageCommand = new DelegateCommand<string>(GotoLastPageCommandExecute, delegate(string param) { return true; });
                return bookGotoLastPageCommand;
            }
        }

        virtual public void GotoLastPageCommandExecute(string param)
        {
            if (Data != null)
                Service.GotoPage(Data, Data.PageCount);
        }

        #endregion

        #endregion

        #region -----------------INTERNALS-----------------

        public void CacheTimerClockElapsed(object tag, EventArgs args)
        {
            try
            {
                if (this.Data != null)
                {
                    Service.ManageCache(this.Data);
                    RaisePropertyChanged("CacheInfo");
                }
            }
            catch (Exception err)
            {
                ExceptionHelper.Manage("BookViewModelBase:CacheTimerClockElapsed", err);
            }
        }

        #endregion
    }
}