using System;
using System.Collections.Generic;
using System.Data;
using System.Web;
using System.Web.Http;
using System.Web.Http.Description;
using SuperMap.RealEstate.Utility;
using MSPB = SuperMap.RealEstate.MobileServicePlatform.Business;
using ESCom = EShang.Common;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using HZQR.Common;
using RedisHelp;

namespace YFBusinessApi.Controllers
{
    /// <summary>
    /// 驿付商家相关接口
    /// </summary>
    public class BusinessController : BaseController
    {
        #region 方法 -> 小程序授权绑定三步骤

        #region 第一步 -> 小程序登录
        /// <summary>
        /// 小程序登录
        /// </summary>
        /// <param name="wechatAppAppId">小程序APPId</param>
        /// <param name="wechatMiniproToken">小程序登录态</param>
        /// <param name="wechatCode">小程序前端使用wx.login() 从微信服务器获取code</param>
        /// <returns></returns>
        [HttpGet]
        [Route("Business/WeChatLogin")]
        public IHttpActionResult WeChatLogin(string wechatAppAppId, string wechatMiniproToken = "", string wechatCode = "")
        {
            try
            {
                #region 判断参数是否正确
                if ((string.IsNullOrEmpty(wechatMiniproToken) || wechatMiniproToken.ToLower() == "undefined") &&
                   (string.IsNullOrEmpty(wechatCode) || wechatCode.ToLower() == "undefined"))
                {
                    transaction.Rollback();
                    return Ok(Helper.Common.ReturnJson(101, "小程序未授权"));
                }
                #endregion

                string wechatAppOpenid = "";
                ESCom.Model.WeChatAppSign weChatAppSignModel = ESCom.Base.GetWechatAppSignInfo(transaction, wechatAppAppId);

                ESCom.Model.MinProUserInfo minProUserInfo = null;
                if (!string.IsNullOrEmpty(wechatCode) && wechatCode.ToLower() != "undefined")
                {
                    #region 向微信服务器换取用户openId 和session_key
                    JObject wxObject = new JObject();
                    wxObject = ESCom.WeChatHelper.WeChatLogin(wechatAppAppId, weChatAppSignModel.wechatAppAppSecret, wechatCode);
                    //获取用户openId 和session_key出错
                    if (wxObject["ResultCode"].TryParseToInt() != 100)
                    {
                        transaction.Rollback();
                        return Ok(Helper.Common.ReturnJson(wxObject["ResultCode"].TryParseToInt(), wxObject["ResultDesc"].ToString()));
                    }

                    wechatAppOpenid = wxObject["ResultData"]["openid"].TryParseToString();
                    minProUserInfo = ESCom.Member.GetRtWechatAppByOpenId(transaction, weChatAppSignModel.weChatAppSignId, wechatAppOpenid);
                    //session_key是微信服务区生成的针对用户数据加密前面的秘钥，不应该传输到客户端
                    string session_key = wxObject["ResultData"]["session_key"].TryParseToString();
                    //MiniProSessionKey用于存储登录状态校验：session_key + openid
                    wechatMiniproToken = ESCom.MiniProgram.CreateMiniProToken(session_key, wechatAppOpenid);
                    #endregion
                }
                else if (!string.IsNullOrEmpty(wechatMiniproToken) && wechatMiniproToken.ToLower() != "undefined")
                {
                    #region 从登录态中获取用户openId 和session_key
                    JObject tokenObj = (JObject)JsonConvert.DeserializeObject(wechatMiniproToken.ToDecrypt());
                    wechatAppOpenid = tokenObj["openid"].TryParseToString();
                    //根据openId 先取缓存中的小程序用户信息
                    minProUserInfo = ESCom.Member.GetRtWechatAppByOpenId(transaction, weChatAppSignModel.weChatAppSignId, wechatAppOpenid);
                    if (minProUserInfo == null || minProUserInfo.WeChat_MemberId == 0)
                    {
                        //查不到用户信息，或者没有WeChat_MemberId，后面需要授权手机号，则需要判断session是否过期
                        var isValid = ESCom.MiniProgram.CheckSession(Convert.ToDateTime(tokenObj["datetime"]));
                        if (!isValid)
                        {
                            transaction.Rollback();
                            return Ok(Helper.Common.ReturnJson(200, "session已过期"));
                        }
                    }
                    #endregion
                }

                ESCom.Model.MemberLogin memberLogin = new ESCom.Model.MemberLogin();
                memberLogin.MembershipId = minProUserInfo.WeChat_MemberId;
                memberLogin.MembershipName = minProUserInfo.WeChat_MemberName;
                memberLogin.MembershipPhone = minProUserInfo.WeChat_Phone;
                memberLogin.WeChatUserId = minProUserInfo.WeChat_UserId;
                memberLogin.WeChatUserName = minProUserInfo.WeChat_UserName;
                memberLogin.WeChatUserHeadimage = minProUserInfo.WeChat_UserHeadimage;
                memberLogin.WeChatMiniProToken = wechatMiniproToken;

                return Ok(Models.JsonMsg<ESCom.Model.MemberLogin>.Success(memberLogin, 100, "请求成功"));
            }
            catch (Exception ex)
            {
                ErrorLogHelper.Write(ex, "接口【WeChatLogin】", "Business/WeChatLogin");
                transaction.Rollback();

                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 第二步 -> 小程序授权
        /// <summary>
        /// 小程序授权
        /// </summary>
        /// <param name="wechatAppAppId">小程序APPId</param>
        /// <param name="wechatMiniproToken">小程序登录态</param>
        /// <param name="encryptedData">小程序端 wx.getUserInfo向微信服务区请求拿到encryptedData ,编码后传入</param>
        ///  <param name="iv">小程序端 wx.getUserInfo向微信服务区请求拿到iv ,编码后传入</param>
        /// <returns></returns>
        [HttpGet]
        [Route("Business/WeChatLicensed")]
        public IHttpActionResult WeChatLicensed(string wechatAppAppId, string wechatMiniproToken, string encryptedData, string iv)
        {
            try
            {
                #region 请求参数
                string _encryptedData = HttpUtility.UrlDecode(encryptedData);
                string _iv = HttpUtility.UrlDecode(iv);
                if (string.IsNullOrEmpty(wechatMiniproToken) || wechatMiniproToken.ToLower() == "undefined")
                {
                    return Ok(Helper.Common.ReturnJson(101, "小程序未授权"));
                }
                if (string.IsNullOrEmpty(encryptedData) || encryptedData.ToLower() == "undefined" ||
                    string.IsNullOrEmpty(iv) || iv.ToLower() == "undefined")
                {
                    return Ok(Helper.Common.ReturnJson(999, "encryptedData或者iv参数有误"));
                }
                #endregion

                //判断令牌是否有效
                JObject tokenObj = (JObject)JsonConvert.DeserializeObject(wechatMiniproToken.ToDecrypt());
                string wechatAppOpenid = tokenObj["openid"].TryParseToString();
                string session_key = tokenObj["session_key"].TryParseToString();

                //微信小程序解密用户信息
                MSPB.CommonHelper.WechatUserInfo userInfo = null;

                try
                {
                    userInfo = MSPB.CommonHelper.WeChatAppDecrypt.Decrypt(_encryptedData, _iv, session_key);
                }
                catch (Exception ex)
                {
                    return Ok(Helper.Common.ReturnJson(999, "encryptedData或者iv参数有误"));
                }

                //先判断小程序用户是否已存在
                ESCom.Model.WeChatAppSign weChatAppSignModel = ESCom.Base.GetWechatAppSignInfo(transaction, wechatAppAppId);
                ESCom.Model.MinProUserInfo minProUser = ESCom.Member.GetRtWechatAppByOpenId(transaction,
                    weChatAppSignModel.weChatAppSignId, wechatAppOpenid);

                #region 插入小程序用户信息
                MSPB.RTWECHATAPP _RTWECHATAPP = new MSPB.RTWECHATAPP(transaction);
                if (minProUser == null)
                {
                    _RTWECHATAPP.ResetProperty();
                    _RTWECHATAPP.WECHATAPPSIGN_ID = weChatAppSignModel.weChatAppSignId;
                    _RTWECHATAPP.WECHATPUBLICSIGN_ID = weChatAppSignModel.weChatPublicSignId;
                    _RTWECHATAPP.WECHATAPP_OPENID = userInfo.openId;
                    _RTWECHATAPP.NICK_NAME = userInfo.nickName;
                    _RTWECHATAPP.USER_GENDER = short.Parse(userInfo.gender);
                    _RTWECHATAPP.USER_CITY = userInfo.city;
                    _RTWECHATAPP.USER_PROVINCE = userInfo.province;
                    _RTWECHATAPP.USER_COUNTRY = userInfo.country;
                    _RTWECHATAPP.USER_AVATARURL = userInfo.avatarUrl;
                    _RTWECHATAPP.USER_UNIONID = userInfo.unionId;
                    _RTWECHATAPP.RTWECHATAPP_STATE = 1;
                    _RTWECHATAPP.ADDTIME = DateTime.Now;
                    _RTWECHATAPP.Insert();
                }
                else
                {
                    _RTWECHATAPP.RTWECHATAPP_ID = minProUser.WeChat_UserId;
                    _RTWECHATAPP.NICK_NAME = userInfo.nickName;
                    _RTWECHATAPP.USER_GENDER = short.Parse(userInfo.gender);
                    _RTWECHATAPP.USER_CITY = userInfo.city;
                    _RTWECHATAPP.USER_PROVINCE = userInfo.province;
                    _RTWECHATAPP.USER_COUNTRY = userInfo.country;
                    _RTWECHATAPP.USER_AVATARURL = userInfo.avatarUrl;
                    _RTWECHATAPP.USER_UNIONID = userInfo.unionId;
                    _RTWECHATAPP.OPERATE_DATE = DateTime.Now;
                    _RTWECHATAPP.Update();
                }

                //更新redis缓存
                string key = weChatAppSignModel.weChatAppSignId + ":" + wechatAppOpenid;//按小程序ID来存储更方便查看
                minProUser.WeChat_UseOpenId = wechatAppOpenid;//存下openId,获取用户详情信息时更新用户信息时用到
                minProUser.WeChat_UserId = _RTWECHATAPP.RTWECHATAPP_ID.Value;
                minProUser.WeChat_UserName = _RTWECHATAPP.NICK_NAME;
                minProUser.WeChat_UserHeadimage = _RTWECHATAPP.USER_AVATARURL;
                minProUser.WeChat_UserSex = _RTWECHATAPP.USER_GENDER.TryParseToInt();
                int? validDay = 7;//存储7天后过期
                ESCom.Redis.StringSet(0, key, minProUser, validDay);//序列化以后存入库中
                #endregion

                #region 返回参数
                ESCom.Model.MemberLogin memberLogin = new ESCom.Model.MemberLogin();
                memberLogin.MembershipId = minProUser.WeChat_MemberId;
                memberLogin.MembershipName = minProUser.WeChat_MemberName;
                memberLogin.MembershipPhone = minProUser.WeChat_Phone;
                memberLogin.WeChatUserId = minProUser.WeChat_UserId;
                memberLogin.WeChatUserName = minProUser.WeChat_UserName;
                memberLogin.WeChatUserHeadimage = minProUser.WeChat_UserHeadimage;
                return Ok(Models.JsonMsg<ESCom.Model.MemberLogin>.Success(memberLogin, 100, "请求成功"));
                #endregion
            }
            catch (Exception ex)
            {
                ErrorLogHelper.Write(ex, "接口【WeChatLicensed】", "Business/WeChatLicensed");
                transaction.Rollback();

                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 第三步 -> 小程序绑定会员手机号
        /// <summary>
        /// 小程序绑定会员手机号
        /// </summary>
        /// <param name="wechatAppAppId">小程序APPId</param>
        /// <param name="wechatUserId">小程序用户Id</param>
        /// <param name="wechatMiniproToken">小程序登录态</param>
        /// <param name="encryptedData">小程序端getPhoneNumber 向微信服务区请求拿到encryptedData,编码后传入</param>
        /// <param name="iv">小程序端getPhoneNumber 向微信服务区请求拿到iv,编码后传入 </param>
        /// <param name="ownerUnitId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("Business/WeChatBindPhone")]
        public IHttpActionResult WeChatBindPhone(string wechatAppAppId, string wechatMiniproToken,
            string encryptedData, string iv, int? wechatUserId = null, int? ownerUnitId = null)
        {
            try
            {
                #region 请求参数
                if (string.IsNullOrEmpty(wechatMiniproToken) || wechatMiniproToken.ToLower() == "undefined")
                {
                    return Ok(Helper.Common.ReturnJson(101, "小程序未授权"));
                }

                if (string.IsNullOrEmpty(encryptedData) || encryptedData.ToLower() == "undefined" ||
                    string.IsNullOrEmpty(iv) || iv.ToLower() == "undefined")
                {
                    return Ok(Helper.Common.ReturnJson(200, "用户拒绝授权"));
                }

                string _encryptedData = HttpUtility.UrlDecode(encryptedData);
                string _iv = HttpUtility.UrlDecode(iv);
                #endregion

                #region 解密令牌
                string session_key = "", wechatAppOpenid = "";
                DateTime? tokenAddTime = null;
                try
                {
                    JObject tokenObj = (JObject)JsonConvert.DeserializeObject(wechatMiniproToken.ToDecrypt());
                    session_key = tokenObj["session_key"].TryParseToString();
                    wechatAppOpenid = tokenObj["openid"].TryParseToString();
                    tokenAddTime = tokenObj["datetime"].TryParseToDateTime();
                    var isValid = ESCom.MiniProgram.CheckSession(Convert.ToDateTime(tokenAddTime));
                    if (!isValid)
                    {
                        return Ok(Helper.Common.ReturnJson(200, "session已过期"));
                    }
                }
                catch (Exception ex)
                {
                    SuperMap.RealEstate.Utility.ErrorLogHelper.Write(ex, "接口WeChat_BusinessPhone", "解密令牌有误" + wechatMiniproToken);
                    return Ok(Helper.Common.ReturnJson(999, "参数wechatMiniproToken有误，" + ex.ToString()));
                }
                #endregion

                string mobilePhone = "", memberName = "";

                #region 解密手机号码
                try
                {
                    string jsonStr = ESCom.WeChatHelper.Decrypt(_encryptedData, _iv, session_key);
                    JObject phoneObj = JObject.Parse(jsonStr);
                    mobilePhone = phoneObj["phoneNumber"].TryParseToString();
                }
                catch (Exception ex)
                {
                    SuperMap.RealEstate.Utility.ErrorLogHelper.Write(ex, "接口WeChat_BusinessPhone", "解密手机号码有误" + wechatMiniproToken);
                    return Ok(Helper.Common.ReturnJson(999, "解密手机号码有误，" + ex.ToString()));
                }
                #endregion

                #region 取出redis中的小程序用户信息
                ESCom.Model.WeChatAppSign weChatAppSignModel = ESCom.Base.GetWechatAppSignInfo(transaction, wechatAppAppId);
                if (ownerUnitId == null && weChatAppSignModel != null)
                {
                    ownerUnitId = weChatAppSignModel.ownerUnitId;//未传业主单位Id则为小程序所属业主单位
                }
                ESCom.Model.MinProUserInfo minProUser = ESCom.Member.GetRtWechatAppByOpenId(transaction,
                    weChatAppSignModel.weChatAppSignId, wechatAppOpenid);
                if (minProUser == null)
                {
                    minProUser = new ESCom.Model.MinProUserInfo();
                    minProUser.WeChat_UserId = wechatUserId.TryParseToInt();
                }
                else
                {
                    memberName = minProUser.WeChat_UserName;
                }
                #endregion

                MSPB.BUSINESSMAN _BUSINESSMAN = new MSPB.BUSINESSMAN(transaction);
                ESCom.Model.MinProUserInfo memberModel = ESCom.BusinessMan.GetBusinessManByMobile(
                    transaction, ownerUnitId.TryParseToInt(), mobilePhone);
                if (memberModel == null)
                {
                    #region 注册新会员
                    ESCom.Model.OwnerUnit ownerUnit = ESCom.Base.GetOwnerUnitInfo(transaction, ownerUnitId.TryParseToInt());
                    string staffName = "小程序注册";
                    _BUSINESSMAN = ESCom.BusinessMan.AddMemberShip(transaction, mobilePhone, memberName, wechatUserId, staffName);
                    #endregion
                }
                else
                {
                    #region 更新原来的用户信息
                    _BUSINESSMAN.BUSINESSMAN_ID = memberModel.WeChat_MemberId;
                    _BUSINESSMAN.RTWECHATAPP_ID = minProUser.WeChat_UserId;
                    _BUSINESSMAN.OPERATE_DATE = DateTime.Now;
                    _BUSINESSMAN.Update();
                    #endregion
                }

                #region 更新redis 小程序用户，存储7天
                try
                {
                    string key = weChatAppSignModel.weChatAppSignId + ":" + wechatAppOpenid;//按小程序ID来存储更方便查看
                    minProUser.WeChat_UseOpenId = wechatAppOpenid;//存下openId,获取用户详情信息时更新用户信息时用到
                    minProUser.WeChat_Phone = mobilePhone;
                    minProUser.WeChat_MemberId = _BUSINESSMAN.BUSINESSMAN_ID.Value;
                    minProUser.WeChat_MemberName = memberName;
                    int? validDay = 7;//存储7天后过期
                    ESCom.Redis.StringSet(0, key, minProUser, validDay);//序列化以后存入库中
                }
                catch (Exception ex)
                {
                    SuperMap.RealEstate.Utility.ErrorLogHelper.Write(ex,
                        "接口【WeChatBindPhone】", "注册写入redis db1：" + wechatAppOpenid);
                }
                #endregion

                #region 更新小程序人员表的会员ID/手机号码
                MSPB.RTWECHATAPP _RTWECHATAPP = new MSPB.RTWECHATAPP(transaction);
                _RTWECHATAPP.RTWECHATAPP_ID = minProUser.WeChat_UserId;
                _RTWECHATAPP.MEMBERSHIP_ID = _BUSINESSMAN.BUSINESSMAN_ID;
                _RTWECHATAPP.PHONE_NUMBER = mobilePhone;
                _RTWECHATAPP.OPERATE_DATE = DateTime.Now;
                _RTWECHATAPP.Update();
                #endregion

                #region 返回参数
                ESCom.Model.MemberLogin memberLogin = new ESCom.Model.MemberLogin();
                memberLogin.MembershipId = minProUser.WeChat_MemberId;
                memberLogin.MembershipName = minProUser.WeChat_MemberName;
                memberLogin.MembershipPhone = minProUser.WeChat_Phone;
                memberLogin.WeChatUserId = minProUser.WeChat_UserId;
                memberLogin.WeChatUserName = minProUser.WeChat_UserName;
                memberLogin.WeChatUserHeadimage = minProUser.WeChat_UserHeadimage;
                memberLogin.WeChatMiniProToken = wechatMiniproToken;
                return Ok(Models.JsonMsg<ESCom.Model.MemberLogin>.Success(memberLogin, 100, "请求成功"));
                #endregion
            }
            catch (Exception ex)
            {
                ErrorLogHelper.Write(ex, "接口【WeChatBindPhone】", "Business/WeChatBindPhone");
                transaction.Rollback();

                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #endregion

        #region 方法 -> 获取商家详情信息
        /// <summary>
        /// 微信端接口：获取商家详情信息
        /// </summary>
        /// <param name="memberShipId">会员ID</param>
        /// <param name="WeChat_AppId">微信小程序AppId</param>
        /// <returns></returns>
        [Route("Business/GetMemberBusinessInfo")]
        [AcceptVerbs("GET", "POST")]
        public IHttpActionResult GetMemberBusinessInfo(int memberShipId, string WeChat_AppId)
        {
            try
            {
                JObject Data = new JObject();

                #region 获取会员信息
                RedisHelper redisMember = new RedisHelper(3);//从redis中取
                ESCom.Model.RedisMember redisUser = new ESCom.Model.RedisMember();
                if (redisMember.KeyExists(memberShipId.ToString()))
                {
                    //获取会员信息
                    redisUser = redisMember.StringGet<ESCom.Model.RedisMember>(memberShipId.ToString());
                }
                else
                {
                    //若缓存中不存在对应商家信息，则读取会员信息存储于缓存中
                    MSPB.BUSINESSMAN _BUSINESSMAN = ESCom.BusinessMan.GetBusinessManModelById(transaction, memberShipId);
                    if (_BUSINESSMAN.PropertyObject != null && _BUSINESSMAN.BUSINESSMAN_ID != null)
                    {
                        redisUser.WeChat_MemberId = _BUSINESSMAN.BUSINESSMAN_ID.Value;      //会员内码
                        redisUser.WeChat_MemberName = _BUSINESSMAN.BUSINESSMAN_NAME;        //会员名称
                        redisUser.WeChat_Phone = _BUSINESSMAN.BUSINESSMAN_MOBILEPHONE;      //手机号码
                        redisUser.WeChat_MemberType = _BUSINESSMAN.BUSINESSMAN_TYPE.Value;  //会员类型
                        redisUser.UserId = _BUSINESSMAN.USER_ID;                            //平台账号内码
                        redisUser.UserOwnerUnitId = _BUSINESSMAN.OWNERUNIT_ID.Value;        //业主单位内码
                        redisUser.UserOwnerUnitName = _BUSINESSMAN.OWNERUNIT_NAME;          //业主单位名称
                    }
                }
                #endregion

                #region 业主单位、授权的门店权限，并记录Redis缓存信息
                if (redisUser.UserId != null)
                {
                    //获取门店权限集合
                    JObject shopInfo = QRWL.Common.JsonHelper.DataTableToJObject(
                        ESCom.BusinessMan.GetShopPermission(transaction, redisUser.UserId.Value));
                    Data["ServerpartList"] = shopInfo["List"];
                }
                #endregion

                //获取用户权限模块
                Data["AuthorityInfo"] = ESCom.Member.GetObjMemberModule(transaction, redisUser.WeChat_MemberId, WeChat_AppId);

                #region 商家详情信息
                //写入redis，后面的逻辑判断都从redis的db4中取
                ESCom.Redis.StringSet(3, memberShipId.ToString(), redisUser, 14);
                //返回给前端的内容
                Data["Membership_Id"] = redisUser.WeChat_MemberId;          //会员内码
                Data["Membership_Name"] = redisUser.WeChat_MemberName;      //会员名称
                Data["Membership_Phone"] = redisUser.WeChat_Phone;          //手机号码
                Data["Membership_Headimage"] = redisUser.WeChat_Headimage;  //头像地址
                Data["Membership_Type"] = redisUser.WeChat_MemberType;      //会员类型
                Data["OwnerUnitName"] = redisUser.UserOwnerUnitName;        //业主单位名称
                #endregion

                return Ok(Helper.Common.ReturnJson(100, "查询成功!", Data));
            }
            catch (Exception ex)
            {
                ErrorLogHelper.Write(ex, "接口【GetMemberBusinessInfo】", "Business/GetMemberBusinessInfo");
                transaction.Rollback();

                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion

        #region 方法 -> 首页 - 获取待处理任务
        /// <summary>
        /// 首页 - 获取待处理任务
        /// </summary>
        /// <param name="memberShipId">会员ID</param>
        /// <returns></returns>
        [Route("Business/GetPendingInfo")]
        [AcceptVerbs("GET", "POST")]
        [ResponseType(typeof(Models.JsonMsg<Models.PendingModel>))]
        public IHttpActionResult GetPendingInfo(string memberShipId)
        {
            try
            {
                Models.PendingModel pendingModel = Helper.PowerHelper.GetPendingInfo(transaction, memberShipId);

                return Ok(Models.JsonMsg<Models.PendingModel>.Success(pendingModel, 100, "查询成功"));
            }
            catch (Exception ex)
            {
                ErrorLogHelper.Write(ex, "接口【Business/GetPendingInfo】", "");
                transaction.Rollback();

                return Ok(Helper.Common.ReturnJson(999, "查询失败" + ex.Message));
            }
        }
        #endregion
    }
}