using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
namespace Admin.NET.Application;
/// <summary>
/// 条码生成规则服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsSystemConfigGroupName, Order = 100)]
public class WmsSncodeCreateRuleService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsConfigSncodeRule> _rep;
    public WmsSncodeCreateRuleService(SqlSugarRepository<WmsConfigSncodeRule> rep)
    {
        _rep = rep;
    }

    /// <summary>
    /// 分页查询条码生成规则
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("WmsSncodeCreateRule/Page")]
    public async Task<SqlSugarPagedList<WmsSncodeCreateRuleOutput>> Page(WmsSncodeCreateRuleInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 不分页查询条码生成规则
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [Description("WmsSncodeCreateRule/List")]
    public async Task<List<WmsSncodeCreateRuleOutput>> List([FromQuery] WmsSncodeCreateRuleInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").Select<WmsSncodeCreateRuleOutput>().ToListAsync();
    }

    /// <summary>
    /// 增加条码生成规则
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [Description("WmsSncodeCreateRule/Add")]
    public async Task<long> Add(AddWmsSncodeCreateRuleInput input)
    {

        var ruleArr = input.SNCodeRule.Replace('，', ',').Split(',').ToList();
        bool containsValidId = false;

        foreach (var item in ruleArr)
        {
            if (item.ToLower().Contains("id"))
            {
                // 进一步检查是否精确匹配为 "id"
                if (item.Equals("id", StringComparison.OrdinalIgnoreCase))
                {
                    containsValidId = true;
                    break;
                }
             
            }
        }
        if (!containsValidId)
        {
            // 如果没有找到符合要求的 "id" 字段，报错
            throw new Exception("该集合中不包含必须的字段“Id”！");
        }




        var entity = input.Adapt<WmsConfigSncodeRule>();

        //重复性验证
        await CheckExist(entity);

        await _rep.InsertAsync(entity);
        return entity.Id;
    }

    /// <summary>
    /// 删除条码生成规则
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [Description("WmsSncodeCreateRule/Delete")]
    public async Task Delete(DeleteWmsSncodeCreateRuleInput input)
    {
        var entity = await _rep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        //await _rep.FakeDeleteAsync(entity);   //假删除
        await _rep.DeleteAsync(entity);   //真删除
    }

    /// <summary>
    /// 更新条码生成规则
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [Description("WmsSncodeCreateRule/Update")]
    public async Task Update(UpdateWmsSncodeCreateRuleInput input)
    {
        var entity = input.Adapt<WmsConfigSncodeRule>();

        //重复性验证
        await CheckExist(entity, true);

        await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }

    /// <summary>
    /// 获取条码生成规则
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [Description("WmsSncodeCreateRule/Detail")]
    public async Task<WmsConfigSncodeRule> Detail([FromQuery] QueryByIdWmsSncodeCreateRuleInput input)
    {
        return await _rep.GetFirstAsync(u => u.Id == input.Id);
    }





    #region 导入

    /// <summary>
    /// Excel模板导入条码生成规则功能
    /// </summary>
    /// <param name="file">Excel模板文件</param>
    /// <returns>导入的记录数</returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "ImportExcel")]
    [Description("WmsSncodeCreateRule/ImportExcel")]
    public async Task<int> ImportExcelAsync(IFormFile file)
    {
        int _HeadStartLine = 2;//第1行是说明,第2行是列名
        int _DataStartLine = 3;//第3行开始是数据
        DataTable importDataTable = ExcelUtil.ImportExcelToDataTable(file, _HeadStartLine, _DataStartLine);
        var addList = await CommonImport(importDataTable, _DataStartLine);
        await _rep.InsertRangeAsync(addList);
        return addList.Count;
    }

    /// <summary>
    ///  DataTable转换实体对象列表
    /// </summary>
    /// <param name="dataTable"></param>
    /// <param name="dataStartLine">模版列名开始行</param>
    /// <returns></returns>
    private async Task<List<WmsConfigSncodeRule>> CommonImport(DataTable dataTable, int dataStartLine)
    {
        var details = new List<WmsConfigSncodeRule>();
        int index = dataStartLine;//模版列名开始行
        foreach (System.Data.DataRow row in dataTable.Rows)
        {
            index++;
            //导入模版定制化代码（替换模版使用）

            var addItem = new WmsConfigSncodeRule();
            #region 定义变量
            var _RuleCode = "";//规则编号
            var _RuleName = "";//规则名称
            var _DataSource = "";//数据源
            var _SNCodeRule = "";//条码规则
            var _Delimiter = "";//条码分隔符
            var _RuleDesc = "";//条码规则描述
            var _IsDisabled = "";//是否禁用
            var _CreateCodeType = "";//条码类型
            #endregion


            #region 取值
            _RuleCode = row["规则编号"]?.ToString();
            _RuleName = row["规则名称"]?.ToString();
            _DataSource = row["数据源"]?.ToString();
            _SNCodeRule = row["条码规则"]?.ToString();
            _Delimiter = row["条码分隔符"]?.ToString();
            _RuleDesc = row["条码规则描述"]?.ToString();
            _IsDisabled = row["是否禁用"]?.ToString();
            _CreateCodeType = row["条码类型"]?.ToString();
            #endregion


            #region 验证

            if (string.IsNullOrEmpty(_RuleCode))
            {
                throw Oops.Oh($"第{index}行[规则编号]{_RuleCode}不能为空！");
            }

            if (!string.IsNullOrEmpty(_RuleCode))
            {
                addItem.RuleCode = (string)(_RuleCode.Trim());
            }

            if (string.IsNullOrEmpty(_RuleName))
            {
                throw Oops.Oh($"第{index}行[规则名称]{_RuleName}不能为空！");
            }

            if (!string.IsNullOrEmpty(_RuleName))
            {
                addItem.RuleName = (string)(_RuleName.Trim());
            }

            if (string.IsNullOrEmpty(_DataSource))
            {
                throw Oops.Oh($"第{index}行[数据源]{_DataSource}不能为空！");
            }

            if (!string.IsNullOrEmpty(_DataSource))
            {
                addItem.DataSource = (string)(_DataSource.Trim());
            }

            if (string.IsNullOrEmpty(_SNCodeRule))
            {
                throw Oops.Oh($"第{index}行[条码规则]{_SNCodeRule}不能为空！");
            }

            if (!string.IsNullOrEmpty(_SNCodeRule))
            {
                addItem.SNCodeRule = (string)(_SNCodeRule.Trim());
            }

            if (string.IsNullOrEmpty(_Delimiter))
            {
                throw Oops.Oh($"第{index}行[条码分隔符]{_Delimiter}不能为空！");
            }

            if (!string.IsNullOrEmpty(_Delimiter))
            {
                addItem.Delimiter = (string)(_Delimiter.Trim());
            }
            if (!string.IsNullOrEmpty(_RuleDesc))
            {
                addItem.RuleDesc = (string)(_RuleDesc.Trim());
            }

            if (string.IsNullOrEmpty(_IsDisabled))
            {
                throw Oops.Oh($"第{index}行[是否禁用]{_IsDisabled}不能为空！");
            }

            if (!string.IsNullOrEmpty(_IsDisabled))
            {
                if (!_IsDisabled.Equals("是") && !_IsDisabled.Equals("否"))
                {
                    throw Oops.Oh($"第{index}行[是否禁用]{_IsDisabled}值不正确！");
                }
                else
                {
                    bool outIsDisabled = _IsDisabled.Equals("是") ? true : false;
                    addItem.IsDisabled = outIsDisabled;
                }
            }

            if (!string.IsNullOrEmpty(_CreateCodeType))
            {
                Admin.NET.Application.CreateCodeTypeEnum enumCreateCodeType = default(Admin.NET.Application.CreateCodeTypeEnum);

                if (!Enum.TryParse<CreateCodeTypeEnum>(_CreateCodeType, out enumCreateCodeType) && !string.IsNullOrEmpty(_CreateCodeType))
                {
                    throw Oops.Oh($"第{index}行[条码类型]{_CreateCodeType}值不正确！");
                }
                else
                {
                    addItem.CreateCodeType = enumCreateCodeType;
                }

            }
            #endregion


            details.Add(addItem);
        }
        //验重
        await CheckExisitForImport(details);
        return details;
    }

    /// <summary>
    /// 根据版本下载条码生成规则的Excel导入模板
    /// </summary>
    /// <returns>下载的模板文件</returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "DownloadExcelTemplate")]
    [Description("WmsSncodeCreateRule/DownloadExcelTemplate")]
    public IActionResult DownloadExcelTemplate()
    {
        string _path = TemplateConst.EXCEL_TEMPLATEFILE_导入模版路径 + $"\\条码生成规则{TemplateConst.EXCEL_TEMPLATEFILE_导入模版名称后缀}.xlsx";
        var fileName = HttpUtility.UrlEncode($"导入模板(条码生成规则).xlsx", Encoding.GetEncoding("UTF-8"));
        return new FileStreamResult(new FileStream(_path, FileMode.Open), "application/octet-stream") { FileDownloadName = fileName };
    }

    #endregion

    #region 私有方法

    /// <summary>
    /// 公共查询条码生成规则条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsSncodeCreateRuleOutput> CommonPageFilter(WmsSncodeCreateRuleInput input)
    {
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.RuleCode.Contains(input.SearchKey.Trim())
                || u.RuleName.Contains(input.SearchKey.Trim())
                || u.DataSource.Contains(input.SearchKey.Trim())
                || u.SNCodeRule.Contains(input.SearchKey.Trim())
                || u.Delimiter.Contains(input.SearchKey.Trim())
                || u.RuleDesc.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleCode), u => u.RuleCode.Contains(input.RuleCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleName), u => u.RuleName.Contains(input.RuleName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.DataSource), u => u.DataSource.Contains(input.DataSource.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SNCodeRule), u => u.SNCodeRule.Contains(input.SNCodeRule.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Delimiter), u => u.Delimiter.Contains(input.Delimiter.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.RuleDesc), u => u.RuleDesc.Contains(input.RuleDesc.Trim()))
            .WhereIF(input.IsDisabled.HasValue, u => u.IsDisabled == input.IsDisabled)
            .WhereIF(input.CreateCodeType.HasValue, u => u.CreateCodeType == input.CreateCodeType)
            .Select<WmsSncodeCreateRuleOutput>();
        return query;
    }

    /// <summary>
    /// 重复性验证
    /// </summary>
    /// <param name="input">验证对象</param>
    /// <param name="isEdit">是否是编辑</param>
    /// <returns></returns>
    private async Task CheckExist(WmsConfigSncodeRule input, bool isEdit = false)
    {



        //没有配置组合校验，不需要验重


        //没有配置单独校验，不需要验重
    }

    /// <summary>
    /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
    /// </summary>
    /// <param name="inputs"></param>
    /// <returns></returns>
    private async Task CheckExisitForImport(List<WmsConfigSncodeRule> inputs)
    {
        if (inputs?.Count <= 0)
        {
            throw Oops.Oh($"导入数据不能为空");
        }
        //根据组合校验验证表格中中是否已存在相同数据  








        //根据单独校验验证表格中中是否已存在相同数据  



    }
    #endregion

}