using AntDesign;
using AntDesign.TableModels;
using FFmpeg.NET.Services;
using Learn.VideoAnalysis.API.Expand;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Web;
using Microsoft.AspNetCore.DataProtection.KeyManagement;
using SqlSugar;
using System.Data.Common;
using System.Linq.Expressions;
using System.Threading.Tasks;
using VideoAnalysisCore.Common;
using VideoAnalysisCore.Controllers.Dto;
using VideoAnalysisCore.Model;
using VideoAnalysisCore.Model.Dto;
using VideoAnalysisCore.Model.Enum;

namespace Learn.VideoAnalysis.Components.Pages
{
    public partial class VideoTaskPage : ComponentBase
    {

        [Inject] private ConfirmService ComfirmService { get; set; } = default!;
        [Inject] private Repository<VideoTask> taskDB { get; set; } = default!;
        [Inject] private NavigationManager NavigationManager { get; set; } = default!;
        [Inject] private RedisManager redisManager { get; set; } = default!;



        [Inject] private INotificationService _notice { get; set; } = default!;
        IEnumerable<VideoTaskDto> _selectedRows = [];
        ITable _table;

        List<VideoTaskDto> _dataSource = null;
        RefAsync<int> _total = 0;

        bool modalShow = false;

        bool tableLoading = false;
        private VideoTaskDto selectData;
        private bool rowRestartLoading = false;
        private VideoTaskDto reStartTask ;

        static TextValue[] SelectDataSource =
            Enum.GetValues(typeof(RedisChannelEnum))
            .Cast<RedisChannelEnum>()
           .Select(s => new TextValue(s.ToString(), (int)s))
           .ToArray();
        int selectEnum = 1;
        int selectDefaultValue =1;

        /// <summary>
        /// 点击重试
        /// </summary>
        /// <param name="query"></param>
        async void ReStartClick(VideoTaskDto query)
        {
            selectDefaultValue =
               (await redisManager.Redis.HMGetAsync<int>(RedisExpandKey.Task(query.Id), "LastEnum")).FirstOrDefault();
            selectEnum = selectDefaultValue;
            reStartTask = query;
           modalShow = true;
        }
        void PreviewTask(VideoTaskDto task) 
        {
            NavigationManager.NavigateTo("/VideoTaskShow/"+task.Id);
        }
        /// <summary>
        /// 重试
        /// </summary>
        /// <param name="query"></param>
        async void ReStart()
        {
            await redisManager.ClearTaskError(reStartTask.Id);
            _=Task.Run(() =>
                redisManager.InsertChannel((RedisChannelEnum)selectEnum, reStartTask.Id)
            );
            modalShow = false;
        }
        private QueryModel<VideoTaskDto> lastQuery = null;
        /// <summary>
        /// 分页 查询 筛选 时
        /// </summary>
        /// <param name="query"></param>
        /// <param name="changed"></param>
        async void ShowErrorTask(MouseEventArgs e)
        {
            _dataSource = await taskDB.AsQueryable()
                .Where(s => s.ErrorMessage != null && s.ErrorMessage != string.Empty)
                .Select<VideoTaskDto>()
                .ToListAsync();
            _total = _dataSource.Count();
            tableLoading = false;
            StateHasChanged();

        }
        /// <summary>
        /// 分页 查询 筛选 时
        /// </summary>
        /// <param name="query"></param>
        async void OnChange(QueryModel<VideoTaskDto> query)
        {
            lastQuery = query;
            tableLoading = true;
            List<IConditionalModel> where = default!;
            if (query.FilterModel != null && ((query.FilterModel?.Count() ?? 0) > 0))
            {
                where = query.ToSqlSugerWhere();
            }
            _dataSource = await taskDB.AsQueryable()
                .Where(where)
                .Select<VideoTaskDto>()
                .OrderByDescending(s => s.Id)
                .ToPageListAsync(query.PageIndex , query.PageSize, _total);
            
            tableLoading = false;
            StateHasChanged();

        }
        /// <summary>
        /// 刷新数据
        /// </summary>
        /// <param name="rowData"></param>
        public void RowRload(RowData<VideoTaskDto> rowData)
        {
            rowRestartLoading = true;
            var item = rowData.Data;
            if (item is null)
                return;
            var data = redisManager.Redis.HMGet<string>(RedisExpandKey.Task(item.Id),
                "Progress", "LastEnum", "StartTime", "ErrorMessage");
            item.Progress = data[0];
            item.LastEnum = data[1] == null ?default:data[1].ToEnum<RedisChannelEnum>() ?? default;
            item.StartTimeDic = data[2]==null?null: System.Text.Json.JsonSerializer.Deserialize<Dictionary<RedisChannelEnum, DateTime>>(data[2]) ?? null;
            item.ErrorMessage = data[3];
            rowRestartLoading = false;
            var statusStr = "wait";
            var dic = rowData.Data.StartTimeDic;
            if (dic is null)
                statusStr= "wait";
            else if (!string.IsNullOrEmpty(rowData.Data.ErrorMessage))
                statusStr= "error";
            else if (dic.ContainsKey(RedisChannelEnum.结束任务))
                statusStr= "finish";
            item.TaskStatus = statusStr;
            StateHasChanged();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        private string RowST(RowData<VideoTaskDto> rowData, RedisChannelEnum e)
        {
            var dic = rowData.Data.StartTimeDic;
            if (dic is null || !dic.ContainsKey(e))
                return "--";
            return dic[e].ToString();
        }
        private void OnExpand(RowData<VideoTaskDto> rowData)
        {
            if(rowData.Expanded)
                RowRload(rowData);
        }
        /// <summary>
        /// 在渲染页面之后
        /// </summary>
        /// <param name="firstRender"></param>
        /// <returns></returns>
        protected override async Task OnAfterRenderAsync(bool firstRender)
        {

        }
        /// <summary>
        /// 初始化
        /// </summary>
        protected override void OnInitialized()
        {
        }

        private async Task<bool> Comfirm(string message)
        {
            return await ComfirmService.Show(message, "提示", ConfirmButtons.YesNo, ConfirmIcon.Warning) == ConfirmResult.Yes;
        }

    }

}