using ComPDFKitViewer;
using ComPDFKitViewer.AnnotEvent;
using PDF_Office.Model;
using PDF_Office.Model.PropertyPanel.AnnotPanel;
using PDF_Office.ViewModels.Tools;
using Prism.Commands;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace PDF_Office.ViewModels.PropertyPanel.AnnotPanel
{
    public class FreetextAnnotPropertyViewModel : BindableBase, INavigationAware
    {
        private double fillOpacity = 1;
        public double FillOpacity
        {
            get { return fillOpacity; }
            set
            {
                SetProperty(ref fillOpacity, value);
            }
        }

        private Brush selectColor = new SolidColorBrush(Colors.Black);
        public Brush SelectColor
        {
            get { return selectColor; }
            set
            {
                SetProperty(ref selectColor, value);
                AnnotEvent?.UpdateAttrib(AnnotAttrib.FontColor, (selectColor as SolidColorBrush).Color);
                AnnotEvent?.UpdateAnnot();
            }
        }

        private Brush fillColor = new SolidColorBrush(Colors.Transparent);
        public Brush FillColor
        {
            get { return fillColor; }
            set
            {
                SetProperty(ref fillColor, value);
                AnnotEvent?.UpdateAttrib(AnnotAttrib.FillColor, (fillColor as SolidColorBrush).Color);
                AnnotEvent?.UpdateAnnot();
            }
        }

        private FontFamily fontFamily = new FontFamily("Courier");
        public FontFamily TextFontFamily
        {
            get { return fontFamily; }
            set
            {
                SetProperty(ref fontFamily, value);
            }
        }

        private FontWeight fontWeights = FontWeights.Normal;
        public FontWeight TextFontWeights
        {
            get { return fontWeights; }
            set
            {
                SetProperty(ref fontWeights, value);
            }
        }

        private FontStyle fontStyle = FontStyles.Normal;
        public FontStyle TextFontStyle
        {
            get { return fontStyle; }
            set
            {
                SetProperty(ref fontStyle, value);
            }
        }


        private int fontSize = 24;
        public int TextFontSize
        {
            get { return fontSize; }
            set
            {
                SetProperty(ref fontSize, value);
            }
        }

        private List<FontStyleItem> fontStyleList = new List<FontStyleItem>();
        public List<FontStyleItem> FontStyleList
        {
            get { return fontStyleList; }
            set
            {
                SetProperty(ref fontStyleList, value);
            }
        }

        public DelegateCommand<object> SelectedFillOpacityCommand { get; set; }
        public DelegateCommand<object> SelectedFontStyleCommand { get; set; }
        public DelegateCommand<object> SelectedColorCommand { get; set; }
        public DelegateCommand<object> SelectedFillColorCommand { get; set; }
        public DelegateCommand<object> FontFamilyChangedCommand { get; set; }
        public DelegateCommand<object> FontStyleChangedCommand { get; set; }
        public DelegateCommand<object> FontSizeChangedCommand { get; set; }
        public DelegateCommand<object> TextAlignChecked { get; set; }
        

        public event EventHandler<object> LoadPropertyHandler;
        public FreetextAnnotPropertyViewModel()
        {
            SelectedFillOpacityCommand = new DelegateCommand<object>(SelectedFillOpacity);
            SelectedFontStyleCommand = new DelegateCommand<object>(SelectedFontStyle);
            SelectedColorCommand = new DelegateCommand<object>(SelectedColor_Command);
            SelectedFillColorCommand = new DelegateCommand<object>(SelectedFillColor_Command);
            FontFamilyChangedCommand = new DelegateCommand<object>(FontFamilyChanged_Command);
            FontStyleChangedCommand = new DelegateCommand<object>(FontStyleChanged_Command);
            FontSizeChangedCommand = new DelegateCommand<object>(FontSizeChanged_Command);
            TextAlignChecked = new DelegateCommand<object>(TextAlign_Checked);
            InitVariable();
        }

        private void InitVariable()
        {
            InitFontStyles();
        }

        private void InitFontStyles()
        {
            FontStyleList = LoadFontStyle.Load();
        }
        private void TextAlign_Checked(object obj)
        {
            if (obj != null && (string)obj != null)
            {
                var tag = (string)obj;
                switch (tag)
                {
                    case "AlignLeft":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Left);
                        break;
                    case "AlignCenter":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Center);
                        break;
                    case "AlignRight":
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.TextAlign, TextAlignment.Right);
                        break;
                }
                AnnotEvent?.UpdateAnnot();

            }
        }

        private void SelectedFontStyle(object obj)
        {
            if (obj != null && (FontStyleItem)obj != null)
            {
                var item = (FontStyleItem)obj;

                AnnotEvent?.UpdateAttrib(AnnotAttrib.FontSize, item.mFontSize);

                AnnotEvent?.UpdateAnnot();

            }
        }

        private void SelectedFillOpacity(object obj)
        {
            if (obj != null)
            {
                FillOpacity = (double)obj;
                SelectColor.Opacity = FillOpacity;

                AnnotEvent?.UpdateAttrib(AnnotAttrib.Transparency, FillOpacity);
                AnnotEvent?.UpdateAnnot();
            }
        }

        private void FontSizeChanged_Command(object obj)
        {
            if (obj != null)
            {
                var item = (ComboBoxItem)obj;
                var content = (string)item.Content;
                if (content != null)
                {
                    var intData = int.Parse(content);
                    TextFontSize = intData;
                    AnnotEvent?.UpdateAttrib(AnnotAttrib.FontSize, intData);
                   
                    AnnotEvent?.UpdateAnnot();
                }
            }
        }

        private void FontStyleChanged_Command(object obj)
        {
            if (obj != null)
            {
                var item  = (ComboBoxItem)obj;
                var content = (string)item.Content;
                if (content != null)
                {
                    if (content == "Regular")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontStyle, FontStyles.Normal);
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontWeight, FontWeights.Normal);
                        TextFontWeights = FontWeights.Normal;
                        TextFontStyle = FontStyles.Normal;
                    }


                    if (content == "Bold")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontStyle, FontStyles.Normal);
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontWeight, FontWeights.Bold);
                        TextFontWeights = FontWeights.Bold;
                        TextFontStyle = FontStyles.Normal;
                    }


                    if (content == "Italic")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontStyle, FontStyles.Italic);
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontWeight, FontWeights.Normal);
                        TextFontWeights = FontWeights.Normal;
                        TextFontStyle = FontStyles.Italic;
                    }

                    if (content == "Bold Italic")
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontStyle, FontStyles.Italic);
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontWeight, FontWeights.Bold);
                        TextFontWeights = FontWeights.Bold;
                        TextFontStyle = FontStyles.Italic;
                    }

                    AnnotEvent?.UpdateAnnot();
                }
            }
        }

        private void FontFamilyChanged_Command(object obj)
        {
            if (obj != null)
            {
                if ((int)obj > -1)
                {
                    if ((int)obj == 0)
                    {
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontFamily, new FontFamily("Courier"));
                        TextFontFamily = new FontFamily("Courier");
                    }
                        

                    if ((int)obj == 1)
                    {
                        TextFontFamily = new FontFamily("Helvetica");
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontFamily, new FontFamily("Helvetica"));
                    }
                       

                    if ((int)obj == 2)
                    {
                        TextFontFamily = new FontFamily("Times");
                        AnnotEvent?.UpdateAttrib(AnnotAttrib.FontFamily, new FontFamily("Times"));
                    }
                       

                    AnnotEvent?.UpdateAnnot();
                }
            }

        }

        private void SelectedFillColor_Command(object obj)
        {
            if (obj != null)
            {
                var colorValue = (Color)obj;
                if (colorValue != null)
                {

                    FillColor = new SolidColorBrush(colorValue);
                    FillColor.Opacity = FillOpacity;

                    Dictionary<AnnotArgsType, object> changeData = new Dictionary<AnnotArgsType, object>();
                    changeData[AnnotArgsType.AnnotFreehand] = obj;
                    PropertyPanel.DataChangedInvoke(this, changeData);
                }
            }
        }

        private void SelectedColor_Command(object obj)
        {
            if (obj != null)
            {
                var colorValue = (Color)obj;
                if (colorValue != null)
                {

                    SelectColor = new SolidColorBrush(colorValue);
                    SelectColor.Opacity = FillOpacity;

                    Dictionary<AnnotArgsType, object> changeData = new Dictionary<AnnotArgsType, object>();
                    changeData[AnnotArgsType.AnnotFreehand] = obj;
                    PropertyPanel.DataChangedInvoke(this, changeData);
                }
            }
        }

        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return true;
        }

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
        }

        public AnnotAttribEvent AnnotEvent { get; set; }
        private FreeTextAnnotArgs Annot;
        private AnnotPropertyPanel PropertyPanel;
        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            navigationContext.Parameters.TryGetValue<AnnotPropertyPanel>(ParameterNames.PropertyPanelContentViewModel, out PropertyPanel);
            if (PropertyPanel != null)
            {
                AnnotEvent = PropertyPanel.AnnotEvent;
                Annot = PropertyPanel.annot as FreeTextAnnotArgs;
                LoadPropertyHandler?.Invoke(this, Annot);
            }
        }
    }
}