using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using System.Web.Mvc;
using Abp.Dependency;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;
using WeApp.BaseInfo;
using IwbZero;

namespace WeApp.CommonManager.States
{
    public class StatesManager : IStatesManager, ISingletonDependency
    {
        private ICacheManager CacheManager { get; set; }
        private IRepository<SysState> Repository { get; set; }
        public StatesManager(
            ICacheManager cacheManage,
            IRepository<SysState> repository)
        {
            CacheManager = cacheManage;
            Repository = repository;
        }

        #region GetSelectList

        #region CodeFilter

        public async Task<List<SelectListItem>> GetSelectListAsync(QueryStateDisplayValue input, params string[] codeFilter)
        {
            return await GetSelectListAsync(input.TableName, input.ColumnName, codeFilter);
        }
        public async Task<List<SelectListItem>> GetSelectListAsync(string tableName, string columnName, params string[] codeFilter)
        {
            var sList = new List<SelectListItem>();
            var list = await GetStateListAsync(tableName, columnName, codeFilter);
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Text = l.DisplayValue, Value = l.CodeValue });
            }
            return sList;
        }

        public async Task<string> GetSelectListStrAsync(QueryStateDisplayValue input, params string[] codeFilter)
        {
            return await GetSelectListStrAsync(input.TableName, input.ColumnName, codeFilter);
        }
        public async Task<string> GetSelectListStrAsync(string tableName, string columnName, params string[] codeFilter)
        {
            var options = "";
            var list = await GetStateListAsync(tableName, columnName, codeFilter);
            foreach (var l in list)
            {
                options += $"<option value=\"{l.CodeValue}\" >{l.DisplayValue}</option>\r\n";
            }
            return options;
        }

        #endregion

        #region CodeFilterReversal

        public async Task<List<SelectListItem>> GetSelectListReversalAsync(QueryStateDisplayValue input, params string[] codeFilter)
        {
            return await GetSelectListReversalAsync(input.TableName, input.ColumnName, codeFilter);
        }
        public async Task<List<SelectListItem>> GetSelectListReversalAsync(string tableName, string columnName, params string[] codeFilter)
        {
            var sList = new List<SelectListItem>();
            var list = await GetStateListReversalAsync(tableName, columnName, codeFilter);
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Text = l.DisplayValue, Value = l.CodeValue });
            }
            return sList;
        }

        public async Task<string> GetSelectListStrsReversalAsync(QueryStateDisplayValue input, params string[] codeFilter)
        {
            return await GetSelectListStrsReversalAsync(input.TableName, input.ColumnName, codeFilter);
        }
        public async Task<string> GetSelectListStrsReversalAsync(string tableName, string columnName, params string[] codeFilter)
        {
            var options = "";
            var list = await GetStateListReversalAsync(tableName, columnName, codeFilter);
            foreach (var l in list)
            {
                options += $"<option value=\"{l.CodeValue}\" >{l.DisplayValue}</option>\r\n";
            }
            return options;
        }

        #endregion

        #region Exp
        public async Task<List<SelectListItem>> GetSelectListAsync(QueryStateDisplayValue input, Expression<Func<SysState, bool>> exp = null)
        {
            return await GetSelectListAsync(input.TableName, input.ColumnName, exp);
        }
        public async Task<List<SelectListItem>> GetSelectListAsync(string tableName, string columnName, Expression<Func<SysState, bool>> exp = null)
        {
            var sList = new List<SelectListItem>();
            var list = await GetStateListAsync(tableName, columnName, exp);
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Text = l.DisplayValue, Value = l.CodeValue });
            }
            return sList;
        }
        public async Task<string> GetSelectListStrAsync(QueryStateDisplayValue input, Expression<Func<SysState, bool>> exp = null)
        {
            return await GetSelectListStrAsync(input.TableName, input.ColumnName, exp);
        }
        public async Task<string> GetSelectListStrAsync(string tableName, string columnName, Expression<Func<SysState, bool>> exp = null)
        {
            var options = "";
            var list = await GetStateListAsync(tableName, columnName, exp);
            foreach (var l in list)
            {
                options += $"<option value=\"{l.CodeValue}\" >{l.DisplayValue}</option>\r\n";
            }
            return options;
        }

        #endregion

        #region StateDisplayDto

        public async Task<List<StateDisplayDto>> GetStateListAsync(QueryStateDisplayValue input, Expression<Func<SysState, bool>> exp = null)
        {
            return await GetStateListAsync(input.TableName, input.ColumnName, exp);
        }
        public async Task<List<StateDisplayDto>> GetStateListAsync(string tableName, string columnName, Expression<Func<SysState, bool>> exp = null)
        {
            var list =  Repository.GetAll().Where(a => a.TableName == tableName && a.ColumnName == columnName);
               
            if (exp != null)
            {
                list = list.Where(exp);
            }

            var dtoList = await list.Select(a => new StateDisplayDto()
            {
                CodeValue = a.CodeValue,
                DisplayValue = a.DisplayValue
            }).ToListAsync();
            return dtoList;
        }


        public async Task<List<StateDisplayDto>> GetStateListAsync(string tableName, string columnName, params string[] codeFilter)
        {
            var list = await Repository.GetAllListAsync(a => a.TableName == tableName && a.ColumnName == columnName);
            if (codeFilter.Any())
            {
                foreach (var code in codeFilter)
                {
                    list = list.Where(a => a.CodeValue == code).ToList();
                }
            }
            var dtos = list.Select(a => new StateDisplayDto()
            {
                CodeValue = a.CodeValue,
                DisplayValue = a.DisplayValue
            }).ToList();
            return dtos;
        }
        public async Task<List<StateDisplayDto>> GetStateListReversalAsync(string tableName, string columnName, params string[] codeFilter)
        {
            var list = await Repository.GetAllListAsync(a => a.TableName == tableName && a.ColumnName == columnName);
            if (codeFilter.Any())
            {
                foreach (var code in codeFilter)
                {
                    list = list.Where(a => a.CodeValue != code).ToList();
                }
            }
            var dtos = list.Select(a => new StateDisplayDto()
            {
                CodeValue = a.CodeValue,
                DisplayValue = a.DisplayValue
            }).ToList();
            return dtos;
        }

        #endregion

        #endregion

        #region GetDisplayValue
        public async Task<string> GetDisplayValueAsync(QueryStateDisplayValue input)
        {
            return await GetDisplayValueAsync(input.TableName, input.ColumnName, input.CodeValue);
        }
        public async Task<string> GetDisplayValueAsync(string tableName, string columnName, string codeValue)
        {
            return await CacheManager.GetCache(IwbZeroConsts.SysStateCache).GetAsync(
                 tableName + "." + columnName + "." + codeValue, () => DisplayValueAsync(tableName, columnName, codeValue));
        }
        private async Task<string> DisplayValueAsync(string tableName, string columnName, string codeValue)
        {
            var state = await Repository.FirstOrDefaultAsync(a =>
                a.TableName == tableName && a.ColumnName == columnName && a.CodeValue == codeValue);
            return state?.DisplayValue;
        }
        public string GetDisplayValue(QueryStateDisplayValue input)
        {
            return GetDisplayValue(input.TableName, input.ColumnName, input.CodeValue);
        }
        public string GetDisplayValue(string tableName, string columnName, string codeValue)
        {
            return CacheManager.GetCache(IwbZeroConsts.SysStateCache).Get(
                 tableName + "." + columnName + "." + codeValue, () => DisplayValue(tableName, columnName, codeValue));
        }
        private string DisplayValue(string tableName, string columnName, string codeValue)
        {
            var state = Repository.FirstOrDefault(a =>
               a.TableName == tableName && a.ColumnName == columnName && a.CodeValue == codeValue);
            return state?.DisplayValue;
        }

        #endregion

    }
}