using AntDesign;
using AntDesign.ProLayout;
using AntDesign.TableModels;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using wispro.sp.entity;
using wispro.sp.share;
using wispro.sp.web.Models;
using wispro.sp.web.Services;


namespace wispro.sp.web.Pages.AppCase
{
    [Authorize]
    public partial class MyCaselist
    {
        const string strAgentFeedbackMemo = "AgentFeedbackMemo";
        const string strDoItemCoefficient = "DoItemCoefficient";
        const string strReturnCasseNo = "ReturnCasseNo";
        const string strCaseCoefficient = "CaseCoefficient";
        const string strWordCount = "WordCount";

        public TableFilter<string>[] CaseCoeFilters = new TableFilter<string>[] {
            new() { Text = "S", Value = "S" },
            new() { Text = "A", Value = "A" },
            new() { Text = "B", Value = "B" },
            new() { Text = "C", Value = "C" },
            new() { Text = "D", Value = "D" }
        };
        
        [Inject]
        protected AppealTypeService apTypeService { get; set; }

        private List<PerformanceItem> _Datas;
        private List<StaffStatistics> MyStatistics;
        IEnumerable<PerformanceItem> selectedItems= new List<PerformanceItem>();
        private CalMonth HandlingCalMonth;
        

        int _pageIndex = 1;
        int _pageSize = 10;
        int _total;
        bool _loading = false;
        PerformanceItem EditingItem = null;
        bool _visible = false;
        bool _isAdd = false;

        List<TabPaneItem> tabList = new List<TabPaneItem>() { 
            new TabPaneItem(){ Key ="myList", Tab ="本月待确认绩效" },
            new TabPaneItem(){  Key ="myAll", Tab ="往期已计算绩效"},
        };

        [Inject] public PerformanceItemServices _ItemService { get; set; }
        [Inject] public MessageService _message { get; set; }
        [Inject] protected NavigationManager NavigationManager { get; set; }
        [Inject] protected IUserService _userService { get; set; }

        [Inject] protected CalMonthServices _CalMonthService { get; set; }


        private bool isFirstInit = true;
        private Table<PerformanceItem> table;
        private CurrentUser _user;
        private  string strAddProjectJX ="";
        protected async override Task OnInitializedAsync()
        {
            if (isFirstInit)
            {
                var Roles = await _authService.GetRoles("AddProjectJX");
                foreach(var role in Roles)
                {
                    strAddProjectJX = (string.IsNullOrEmpty(strAddProjectJX)) ? role : $"{strAddProjectJX},{role}";
                }

                _loading = true;
                await RefreshMyStatistics();
                _Datas = new List<PerformanceItem>();// data.Results;
                _total = 0;//data.TotalCount;
                _loading = false;
            }

            isFirstInit = false;
            await apTypeService.GetItems();
            _user =await _userService.GetUser();
            StateHasChanged();
        }

        private async Task RefreshMyStatistics()
        {
            var HandlingCalMonth = await _CalMonthService.GetHandlingMonth();
            if (HandlingCalMonth != null)
            {
                var _user = await _userService.GetUser(); ;
                if (_user.Userid != null)
                {
                    MyStatistics = await _ItemService.CalMyStatistics(HandlingCalMonth.Year, HandlingCalMonth.Month, _user.Userid.Value);
                }
                else
                {
                    NavigationManager.NavigateTo("/LoginPages");
                }
            }
            
        }

        private string GetStatistics(string strType,bool isBasePoint=false)
        {
            try
            {
                if (strType != "ALL")
                {

                    var tem = MyStatistics.Where<StaffStatistics>(s => s.jxType == strType).FirstOrDefault();

                    if (isBasePoint)
                    {
                        if (tem != null)
                        {
                            return (tem.totalBasePoint.HasValue ? tem.totalBasePoint.Value.ToString("0.00") : "");
                        }
                        else
                        {
                            return "";
                        }
                    }
                    else
                    {
                        if (tem != null)
                        {
                            return (tem.totalActuallyPoint.HasValue ? tem.totalActuallyPoint.Value.ToString("0.00") : "");
                        }
                        else
                        {
                            return "";
                        }
                    }
                    
                }
                else
                {
                    if (isBasePoint)
                    {
                        return MyStatistics.Select(s => s.totalBasePoint.Value).Sum().ToString("0.00");
                    }
                    else
                    {
                        return MyStatistics.Select(s => s.totalActuallyPoint.Value).Sum().ToString("0.00");
                    }
                }
            }
            catch
            {
                return "";
            }
        }

        private int serialNumber(int pageIndex, int pageSize, int id)
        {
            int iIndex = 0;
            foreach (PerformanceItem sf in _Datas)
            {
                iIndex++;

                if (sf.Id == id)
                {
                    break;
                }
            }
            return (pageIndex - 1) * pageSize + iIndex;
        }


        private async Task HandleTableChange(QueryModel<PerformanceItem> queryModel)
        {
            var _user = await _userService.GetUser();
            if (_CurrentKey == tabList[0].Key)
            {
                _loading = true;
                
                var data = await _ItemService.Query(_user.Userid.Value, jxType.doing, queryModel);

                _Datas = data.Results;
                _total = data.TotalCount;
                _loading = false;
                StateHasChanged();
            }
            else
            {
                _loading = true;
                var data = await _ItemService.Query(_user.Userid.Value, jxType.finished, queryModel);

                _Datas = data.Results;
                _total = data.TotalCount;
                _loading = false;
                StateHasChanged();
            }

            
        }

        private void OnsubShensu(PerformanceItem Item)
        {
            EditingItem = Item;
            _visible = true;

            //return new EventCallback();
        }

        bool _ShowJXModal = false;
        private void OnJXCal(PerformanceItem Item)
        {
            EditingItem = Item;
            _ShowJXModal = true;
        }

        private shensuType _SelectedItem;
        private void OnSelectedItemChangedHandler(shensuType value)
        {
            _SelectedItem = value;
            //StaffGradeIdChanged.InvokeAsync(_SelectedItem.Id);
        }

        #region 特殊绩效字段选择框变更时处理代码
        void SelectChanged(Reason  value)
        {
            if (!_loading && EditingItem != null)
            {

                var respone = _ItemService.SaveFieldChange(EditingItem.Id, strAgentFeedbackMemo, EditingItem.AgentFeedbackMemo);
                EditingItem = null;
                _ = RefreshMyStatistics();
                table.ReloadData();
            }
        }

        void ClearSelect(int itemId)
        {
            var respone = _ItemService.SaveFieldChange(itemId, strAgentFeedbackMemo,"");
            EditingItem = null;

            _ = RefreshMyStatistics();
            table.ReloadData();
        }
        #endregion

        Dictionary<string, object> OnRow(RowData<PerformanceItem> row)
        {
            Dictionary<string, object> ret = new Dictionary<string, object>();

            
            ret.Add("onclick", ((Action)delegate
            {
                EditingItem = row.Data;
            }));


            return ret;
        }

        void OnFocus(PerformanceItem item)
        {
            EditingItem = item;
        }

        string _CurrentKey = "myList";
        void OnTabChange(string key)
        {
            _CurrentKey = key;
            table.ReloadData();
            StateHasChanged();
        }

        private ModalRef _modalRef;
        [Inject] ModalService _ModalService { get; set; }
        [Inject]protected AppealTypeService _atService { get; set; }

        
        async Task ShowModel(PerformanceItem Item,AppealType appealType)
        {
            var templateOptions = new Models.CreateAppealModel();
            await templateOptions.Init(_atService,Item, appealType);

            var modalConfig = new ModalOptions();
            modalConfig.Title = appealType.Name;
            modalConfig.Width = 650;
            //modalConfig.Footer = null;
            modalConfig.DestroyOnClose = true;


            _modalRef = await _ModalService
                .CreateModalAsync<Components.CreateAppeal, Models.CreateAppealModel>(modalConfig, templateOptions);

            _modalRef.OnOpen = () =>
            {
                return Task.CompletedTask;
            };

            _modalRef.OnOk = async () =>
            {
                try
                {
                    await _atService.CreateAppeal(templateOptions);
                    await _modalRef.CloseAsync();

                    StateHasChanged();

                    var SuccessConfig = new ConfirmOptions()
                    {
                        Content = @"保存申诉信息成功！"
                    };

                    //modalConfig.Footer = null;
                    modalConfig.DestroyOnClose = true;
                    _ModalService.Success(SuccessConfig);

                }
                catch (Exception ex)
                {
                    _ModalService.Error(new ConfirmOptions()
                    {
                        Title = "保存申诉信息错误",
                        Content = ex.Message,
                    });
                    //_ErrorMessage = ex.Message;
                }

                //return Task.CompletedTask;
            };

            _modalRef.OnCancel = () =>
            {
                return Task.CompletedTask;
            };

            _modalRef.OnClose = () =>
            {
                return Task.CompletedTask;
            };
            StateHasChanged();
        }

        void goAssignPoint()
        {
            NavigationManager.NavigateTo("/Project/AssignPoint");
        }
    }
}
