using AutoMapper;
using Kean.Domain.Material.Models;
using Kean.Infrastructure.Database;
using Kean.Infrastructure.Database.Repository.Default;
using Kean.Infrastructure.Database.Repository.Default.Entities;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Kean.Infrastructure.Repository
{
    /// <summary>
    /// 物料仓库
    /// </summary>
    public class MaterialRepository : 
        Domain.Material.Repositories.IMaterialRepository
    {
        private readonly IMapper _mapper; // 模型映射
        private readonly IDefaultDb _database; // 默认数据库

        /// <summary>
        /// 构造函数
        /// </summary>
        public MaterialRepository(
            IMapper mapper,
            IDefaultDb database)
        {
            _mapper = mapper;
            _database = database;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsMaterialExist 方法
         */
        public async Task<bool> IsMaterialExist(int id)
        {
            return (await _database.From<T_GOODS_MAIN>()
                .Where(g => g.GOODS_FLAG == true && g.GOODS_ID == id)
                .Single(g => new { Count = Function.Count(g.GOODS_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsMaterialCodeExist 方法
         */
        public async Task<bool> IsMaterialCodeExist(string code, int? igrone)
        {
            var schema = _database.From<T_GOODS_MAIN>()
                .Where(g => g.GOODS_FLAG == true && g.GOODS_CODE == code);
            if (igrone.HasValue)
            {
                schema = schema.Where(g => g.GOODS_ID != igrone.Value);
            }
            return (await schema.Single(g => new { Count = Function.Count(g.GOODS_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsMaterialCodeExist 方法
         */
        public async Task<bool> IsMaterialNameExist(string name, int? igrone)
        {
            var schema = _database.From<T_GOODS_MAIN>()
                .Where(g => g.GOODS_FLAG == true && g.GOODS_NAME == name);
            if (igrone.HasValue)
            {
                schema = schema.Where(g => g.GOODS_ID != igrone.Value);
            }
            return (await schema.Single(g => new { Count = Function.Count(g.GOODS_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.CreateMaterial 方法
         */
        public async Task<int> CreateMaterial(Material material)
        {
            //@=@ 固定值
            var entity = _mapper.Map<T_GOODS_MAIN>(material);
            entity.TYPE_ID = "1";
            if (entity.CLASS_ID == 5 || entity.CLASS_ID == 6 || entity.CLASS_ID == 9)
            {
                entity.TYPE_ID = "4";
            }
            entity.GOODS_FLAG = true;
            entity.UPDATE_TIME = entity.CREATE_TIME = DateTime.Now;
            var id = await _database.From<T_GOODS_MAIN>().Add(entity);
            return Convert.ToInt32(id);
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.ModifyMaterial 方法
         */
        public async Task ModifyMaterial(Material material)
        {
            var entity = _mapper.Map<T_GOODS_MAIN>(material);
            entity.GOODS_FLAG = true;
            entity.UPDATE_TIME = DateTime.Now;
            await _database.From<T_GOODS_MAIN>().Update(entity, nameof(T_GOODS_MAIN.CREATE_TIME));
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.DeleteMaterial 方法
         */
        public async Task DeleteMaterial(int id)
        {
            await _database.From<T_GOODS_MAIN>()
                .Where(g => g.GOODS_ID == id)
                .Update(new
                {
                    GOODS_FLAG = false,
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.UnbindMaterialCategory 方法
         */
        public async Task UnbindMaterialCategory(int category)
        {
            await _database.From<T_GOODS_MAIN>()
                .Where(g => g.CLASS_ID == category)
                .Update(new
                {
                    CLASS_ID = default(int?),
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsCategoryExist 方法
         */
        public async Task<bool> IsCategoryExist(int id)
        {
            return (await _database.From<T_GOODS_CLASS>()
                .Where(c => c.CLASS_FLAG == true && c.CLASS_ID == id)
                .Single(c => new { Count = Function.Count(c.CLASS_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsCategoryExist 方法
         */
        public async Task<bool> IsCategoryExist(string name, int? igrone)
        {
            var schema = _database.From<T_GOODS_CLASS>()
                .Where(c => c.CLASS_FLAG == true && c.CLASS_NAME == name);
            if (igrone.HasValue)
            {
                schema = schema.Where(c => c.CLASS_ID != igrone.Value);
            }
            return (await schema.Single(c => new { Count = Function.Count(c.CLASS_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.CreateCategory 方法
         */
        public async Task<int> CreateCategory(Category category)
        {
            var entity = _mapper.Map<T_GOODS_CLASS>(category);
            entity.CLASS_FLAG = true;
            entity.UPDATE_TIME = entity.CREATE_TIME = DateTime.Now;
            var id = await _database.From<T_GOODS_CLASS>().Add(entity);
            return Convert.ToInt32(id);
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.ModifyCategory 方法
         */
        public async Task ModifyCategory(Category category)
        {
            var entity = _mapper.Map<T_GOODS_CLASS>(category);
            entity.CLASS_FLAG = true;
            entity.UPDATE_TIME = DateTime.Now;
            await _database.From<T_GOODS_CLASS>().Update(entity, nameof(T_GOODS_CLASS.CREATE_TIME));
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.DeleteCategory 方法
         */
        public async Task DeleteCategory(int id)
        {
            await _database.From<T_GOODS_CLASS>()
                .Where(c => c.CLASS_ID == id)
                .Update(new
                {
                    CLASS_FLAG = false,
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.UnbindCategoryParent 方法
         */
        public async Task UnbindCategoryParent(int id)
        {
            await _database.From<T_GOODS_CLASS>()
                .Where(c => c.CLASS_PARENT_ID == id)
                .Update(new
                {
                    CLASS_PARENT_ID = 0,
                    UPDATE_TIME = DateTime.Now
                });
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsSafetyExist 方法
         */
        public async Task<bool> IsSafetyExist(int id)
        {
            return (await _database.From<T_GOODS_SAFETY>()
                .Where(s => s.SAFETY_ID == id)
                .Single(s => new { Count = Function.Count(s.SAFETY_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsSafetyExist 方法
         */
        public async Task<bool> IsSafetyExist(int material, IEnumerable<int> warehouse, int? igrone)
        {
            var schema = _database.From<T_GOODS_SAFETY>()
                .Where(s => s.GOODS_ID == material);
            if (igrone.HasValue)
            {
                schema = schema.Where(c => c.SAFETY_ID != igrone.Value);
            }
            return (await schema.Single(c => new { Count = Function.Count(c.SAFETY_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.CreateSafety 方法
         */
        public async Task<int> CreateSafety(Safety safety)
        {
            var timestamp = DateTime.Now;
            var entity = _mapper.Map<T_GOODS_SAFETY>(safety);
            entity.UPDATE_TIME = entity.CREATE_TIME = timestamp;
            var id = Convert.ToInt32(await _database.From<T_GOODS_SAFETY>().Add(entity));
            foreach (var item in safety.Warehouse)
            {
                await _database.From<T_GOODS_SAFETY_LIST>().Add(new()
                {
                    SAFETY_ID = id,
                    WAREHOUSE_ID = item,
                    CREATE_TIME = timestamp,
                    UPDATE_TIME = timestamp
                });
            }
            return id;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.ModifySafety 方法
         */
        public async Task ModifySafety(Safety safety)
        {
            var timestamp = DateTime.Now;
            var entity = _mapper.Map<T_GOODS_SAFETY>(safety);
            entity.UPDATE_TIME = timestamp;
            await _database.From<T_GOODS_SAFETY>().Update(entity, nameof(T_GOODS_SAFETY.CREATE_TIME));
            await _database.From<T_GOODS_SAFETY_LIST>().Where(s => s.SAFETY_ID == safety.Id).Delete();
            //foreach (var item in safety.Warehouse)
            //{
                await _database.From<T_GOODS_SAFETY_LIST>().Add(new()
                {
                    SAFETY_ID = safety.Id,
                    //WAREHOUSE_ID = item,
                    CREATE_TIME = timestamp,
                    UPDATE_TIME = timestamp
                });
            //}
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.DeleteSafety 方法
         */
        public async Task DeleteSafety(int id)
        {
            await _database.From<T_GOODS_SAFETY>().Where(s => s.SAFETY_ID == id).Delete();
            await _database.From<T_GOODS_SAFETY_LIST>().Where(s => s.SAFETY_ID == id).Delete();
        }

        /////////////////////////////////////////////////////////
        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.GetMaterial 方法
         */
        public async Task<string> GetMaterial(int? goodsid, string code, bool bLike)
        {
            var schema = _database.From<T_GOODS_MAIN>();
            if (goodsid.HasValue)
            {
                schema.Where(r => r.GOODS_ID == goodsid);
            }
            else
            {
                if (bLike)
                {
                    schema.Where(r => r.GOODS_CODE.StartsWith(code));
                }
                else
                {
                    schema.Where(r => r.GOODS_CODE == code);
                }
            }

            var material = await schema.Single();
            return JsonConvert.SerializeObject(_mapper.Map<Material>(material));
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.IsPallet 方法
         */
        public async Task<bool> IsPallet(int goodsid)
        {
            return (await _database.From<T_GOODS_MAIN, T_GOODS_CLASS>()
                .Join(Join.Inner, (m, c) => m.CLASS_ID == c.CLASS_ID)
                .Where((m, c) => c.CLASS_FLAG == true && m.GOODS_ID == goodsid && c.CLASS_PARENT_ID == 4)
                .Single((m, c) => new { Count = Function.Count(c.CLASS_ID) })).Count > 0;
        }

        /*
         * 实现 Kean.Domain.Material.Repositories.IMaterialRepository.GetMaterialClass 方法
         */
        public async Task<string> GetMaterialClass(int goodsid)
        {
            var material = _database.From<T_GOODS_MAIN>()
                .Where(r=>r.GOODS_ID == goodsid)
                .Query(r => r.CLASS_ID);

            var calss = await _database.From<T_GOODS_CLASS>()
                .Where(r=> material.Contains(r.CLASS_ID))
                .Single();

            return JsonConvert.SerializeObject(_mapper.Map<Category>(calss));
        }
    }
}