using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading.Tasks;
using Autofac.Core;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using MySqlX.XDevAPI.Common;
using New_College.AuthHelper.OverWrite;
using New_College.IServices;
using New_College.Model;
using New_College.Model.Models;
using New_College.Model.Request;
using New_College.Model.ViewModels;
using Org.BouncyCastle.Asn1.Ocsp;

namespace New_College.Api.Controllers.Front
{
    [Route("api/front/[controller]/[action]")]
    [ApiController]
    [Authorize(Roles = "users")]
    public class CustomerController : ControllerBase
    {
        private readonly IV_CustomerInfoServices _services;
        private readonly ID_UserSettingBaseServices _userSetting;
        private readonly ICasdoorUserServices _casdoorUserServices;
        private readonly ID_FansDistributionServices _fansDistributionServices;
        public CustomerController(IV_CustomerInfoServices IV_CustomerInfoServices, ID_UserSettingBaseServices userSetting, ICasdoorUserServices casdoorUserServices, ID_FansDistributionServices fansDistributionServices)
        {
            _services = IV_CustomerInfoServices;
            _userSetting = userSetting;
            _casdoorUserServices = casdoorUserServices;
            _fansDistributionServices = fansDistributionServices;
        }



        /// <summary>
        ///获取分享好友任务完成情况
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<CustomerShareModel>> ShareTaskFinshing([FromQuery] CustomerShareQuery query)
        {
            var userinfo = new List<CustomerShareItem>();
            var customer = await _fansDistributionServices.Query(c => c.IsDelete == false && c.SaleId == query.CustomerId);
            var fansids = customer.Select(c => c.FansId).ToList();
            userinfo = (await _services.Query(c => fansids.Contains(c.Id))).Select(c => new CustomerShareItem()
            {
                Avatar = c.AvatarUrl,
                nickName = c.NickName
            }).ToList();
            return new MessageModel<CustomerShareModel>()
            {
                response = new CustomerShareModel()
                {
                    ShareItems = userinfo,
                    UnDone = 3 - userinfo.Count()
                },
                success = true,
                msg = "ok"
            };
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sync"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        public async Task<MessageModel<bool>> SyncCustomerInfo([FromBody] SyncCustomerDto sync)
        {

            switch (sync.action)
            {
                case "signup":
                    break;
                case "login":
                case "logout":
                case "update-user":
                case "delete-user":
                case "add-user":
                    if (!string.IsNullOrWhiteSpace(sync.extendedUser.id))
                    {
                        var singlelist = await _services.Query(e => e.UUID == sync.extendedUser.id);
                        if (singlelist.Any())
                        {
                            var single = singlelist.FirstOrDefault();
                            if (single != null)
                            {
                                updatesync(single.Phone);
                                //var custome = new CustomerUpdateQuery()
                                //{
                                //    StudentId = single.Id,
                                //    NickName = sync.extendedUser.displayName,
                                //    Phone = sync.extendedUser.phone,
                                //    Expectedscore = sync.extendedUser.score,
                                //    AvatarUrl = sync.extendedUser.avatar
                                //};
                                //await _services.UpdateCustomer(custome);//注册已后台数据库自动完成
                            }
                        }
                    }
                    break;
            }



            return new MessageModel<bool>()
            {
                msg = "ok",
                response = true,
                success = true
            };
        }



        /// <summary>
        ///账号注销
        /// </summary>
        /// <returns>传入OpenId</returns>
        [HttpPost]
        public async Task<MessageModel<bool>> AccountCancel([FromBody] LoginQuery login)
        {
            var single = await _services.Query(c => c.OpenId == login.openId);
            if (single.Any())
            {
                var newmodel = single.FirstOrDefault();
                newmodel.IsDelete = true;
                var update = await _services.Update(newmodel);
                await _casdoorUserServices.AccontCancel(login.openId);
                return new MessageModel<bool>()
                {
                    success = true,
                    msg = "ok",
                    response = update,
                    status = 200
                };
            }
            return new MessageModel<bool>()
            {
                status = 200,
                response = false,
                msg = "fail",

            };
        }

        /// <summary>
        /// 获取微信openid
        /// </summary>
        /// <param name="login"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        public MessageModel<CustomerInfoResult> GetWxOpenId(WeixinLogin login)
        {
            var response = new CustomerInfoResult();
            try
            {
                var result = _services.AuthCode2Session(login.code);
                if (result.openid != "" && result.openid != null)
                {
                    var loginstatus = _services.Logined(new LoginQuery() { openId = result.openid }).Result;
                    if (loginstatus.Item1)
                    {
                        response = loginstatus.Item2;
                    }
                    else
                    {
                        var save = _services.CustomerSave(new DecryptUserInfoRequest() { openid = result.openid }).Result;
                        response.OpenId = result.openid;
                        response.Id = save;
                    }
                    TokenModelJwt tokenModel = new TokenModelJwt { Uid = response.Id, Role = "users" };
                    response.Token = JwtHelper.IssueJwt(tokenModel);
                    response.session_key = result.session_key;
                    return new MessageModel<CustomerInfoResult>()
                    {
                        success = true,
                        msg = "success",
                        response = response
                    };
                }
                else
                {
                    return new MessageModel<CustomerInfoResult>()
                    {
                        success = false,
                        response = response
                    };
                }
            }
            catch (Exception ex)
            {
                return new MessageModel<CustomerInfoResult>()
                {
                    msg = ex.ToString(),
                    success = false,
                    response = response
                };
            }
        }


        [AllowAnonymous]
        [HttpPost]
        [DisplayName("获取微信用户电话号码")]
        public async Task<MessageModel<string>> GetWxPhone(DecryptUserPhoneRequest request)
        {
            var accessToken = _services.access_Token();
            var reqUserPhoneNumber = new WxaBusinessGetUserPhoneNumberRequest()
            {
                code = request.code,
                access_Token = accessToken.access_token,
            };
            int newId = 0;
            var repUserPhoneNumber = _services.WxaBusinessGetUserPhoneNumber(reqUserPhoneNumber);
            var customerinfo = (await _services.Query(e => e.OpenId == request.openId)).FirstOrDefault();
            customerinfo.Phone = repUserPhoneNumber.phone_info.phoneNumber;
            var result = repUserPhoneNumber.errcode == 0 ? await _services.Update(customerinfo) : false;
            if (result)
            {
                try
                {
                    Task.Run(async () =>
                    {
                        await DistrFanc(request.SaleId, customerinfo.Id);
                    });
                    newId = await updatesync(customerinfo.Phone);

                }
                catch (Exception ex)
                {
                }
            }
            return new MessageModel<string>()
            {
                msg = newId.ToString(),
                response = repUserPhoneNumber.phone_info.phoneNumber,
                success = result ? true : false,
            };
        }



        /// <summary>
        /// 增加粉丝
        /// </summary>
        /// <param name="saleId"></param>
        /// <param name="fancId"></param>
        /// <returns></returns>
        private async Task<bool> DistrFanc(int saleId, int fancId)
        {
            if (saleId > 0)
            {
                var exist = await _fansDistributionServices.Query(q => q.FansId == fancId);
                if (!exist.Any())
                {
                    await _fansDistributionServices.Add(new D_FansDistribution()
                    {
                        CreateTime = DateTime.Now,
                        IsDelete = false,
                        OrderSort = 0,
                        ModifyTime = DateTime.Now,
                        FansId = fancId,
                        SaleId = saleId,
                    });
                    var count = (await _fansDistributionServices.Query(e => e.SaleId == saleId)).Count();//判断邀请人数是否满足三个人
                    if (count >= 3)
                    {
                        await _services.UpdateIsVip(saleId);
                    }
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 同步合并数据
        /// </summary>
        /// <param name="phone"></param>
        /// <returns></returns>
        private async Task<int> updatesync(string phone)
        {
            int newId = 0;
            var customer = await _services.Query(c => c.Phone == phone);
            if (customer.Count() > 1)
            {
                var exists = customer.Exists(e => !string.IsNullOrWhiteSpace(e.UUID));
                if (exists)
                {
                    var firstinfo = customer.FirstOrDefault(e => !string.IsNullOrWhiteSpace(e.UUID));
                    newId = firstinfo.Id;
                    var endinfo = customer.FirstOrDefault(e => e.Id != firstinfo.Id);
                    firstinfo.IsVIP = endinfo.IsVIP ? true : firstinfo.IsVIP;
                    firstinfo.OpenId = endinfo.OpenId;
                    //firstinfo.UserPwd = endinfo.UserPwd;
                    //firstinfo.Salt= endinfo.Salt;   
                    firstinfo.NickName = !string.IsNullOrWhiteSpace(endinfo.NickName) ? endinfo.NickName : firstinfo.NickName;
                    var casdoorinfo = await _casdoorUserServices.QueryById((string)firstinfo.UUID);
                    if (casdoorinfo != null)
                    {

                        casdoorinfo.id_card = firstinfo.OpenId;
                        await _casdoorUserServices.Update(casdoorinfo);
                        await _services.Update(firstinfo);

                        await _services.Delete(endinfo);
                    }
                }
            }
            return newId;
        }


        /// <summary>
        /// 解密手机号同时保存用户信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        [AllowAnonymous]
        public async Task<MessageModel<string>> WeixinDecryptUserInfo(DecryptUserInfoRequest request)
        {
            var phoneinfo = _services.GetWeixinPhone(new GetPhoneInfo()
            {

                encryptedData = request.encryptedData,
                iv = request.iv,
                openid = request.openid,
                session_key = request.session_key
            });
            request.phone = phoneinfo;
            var customerinfo = (await _services.Query(e => e.OpenId == request.openid)).FirstOrDefault();
            customerinfo.AvatarUrl = request.avatarUrl;
            customerinfo.NickName = request.nickName;
            customerinfo.Gender = request.gender;
            customerinfo.Phone = phoneinfo;
            var result = await _services.Update(customerinfo);
            if (result)
            {
                return new MessageModel<string>()
                {
                    msg = result ? "修改成功" : "保存失败",
                    response = phoneinfo,
                    success = result
                };
            }
            else
            {
                return new MessageModel<string>()
                {
                    msg = result ? "修改成功" : "保存失败",
                    response = "0",
                    success = result
                };

            }

        }




        /// <summary>
        ///用户获取用户信息有OpenId 调用此接口
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<CustomerInfoResult>> GetUserInfo([FromQuery] LoginQuery query)
        {
            var result = await _services.GetUserInfo(query);
            return new MessageModel<CustomerInfoResult>()
            {
                response = result.Item2,
                success = result.Item1,
                msg = result.Item1 ? "登陆成功" : "用户不存在"
            };
        }






        /// <summary>
        /// 更改分数
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<MessageModel<CustomerInfoResult>> UpdateScore(UpdateScoreQuery query)
        {
            var customersingle = await _services.QueryById(query.StudentId);
            if (customersingle == null)
            {

                return new MessageModel<CustomerInfoResult>()
                {

                };
            }

            var result = await _services.UpdateScore(query);
            if (result.Id > 0)
            {
                if (query.Score != customersingle.Expectedscore)
                {
                    await _userSetting.UpdateSingleCustomerSetting(new UserBaseSettingUpdateDTO() { UType = 0, CustomerId = query.StudentId });//修改参数次数
                }
                var token = JwtHelper.IssueJwt(new TokenModelJwt() { Uid = result.Id, Role = "学生" });
                result.Token = token;
            }
            return new MessageModel<CustomerInfoResult>()
            {
                success = result.Status == 1,
                msg = result.Status == 1 ? "修改成功" : "修改失败",
                response = result
            };
        }

        /// <summary>
        /// 完善用户信息
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<MessageModel<CustomerInfoResult>> UpdateCustomer([FromBody] CustomerUpdateQuery query)
        {
            var result = await _services.UpdateCustomer(query);
            if (result.Id > 0)
            {
                //if (query.Expectedscore >= 0)
                //{
                //    await _userSetting.UpdateSingleCustomerSetting(new UserBaseSettingUpdateDTO() { UType = 0, CustomerId = query.StudentId });//修改参数次数
                //}
                var token = JwtHelper.IssueJwt(new TokenModelJwt() { Uid = result.Id, Role = "学生" });
                result.Token = token;
            }
            return new MessageModel<CustomerInfoResult>()
            {
                success = result.Status == 1,
                msg = result.Status == 1 ? "成功" : "失败",
                response = result
            };
        }



        /// <summary>
        /// 修改用户头像与名称
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<MessageModel<CustomerInfoResult>> UpdateCustomerAvatarUrl(UpdateCustomerQuery query)
        {
            var result = await _services.UpdateCustomerInfo(query);
            if (result.Id > 0)
            {
                var token = JwtHelper.IssueJwt(new TokenModelJwt() { Uid = result.Id, Role = "学生" });
                result.Token = token;
            }
            return new MessageModel<CustomerInfoResult>()
            {
                success = result.Status == 1,
                msg = result.Status == 1 ? "成功" : "失败",
                response = result
            };
        }


        /// <summary>
        /// 根绝Id获取用户信息
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<CustomerInfoResult>> GetCustomerInfoById([FromQuery] IdQuery query)
        {
            return await _services.GetCustomerInfoById(query);
        }
    }
}