package com.mirage.mirageservice.service;

import com.github.pagehelper.PageHelper;
import com.google.common.collect.Maps;
import com.google.gson.JsonObject;
import com.mirage.core.exception.AppRuntimeException;
import com.mirage.core.meta.PageResultVo;
import com.mirage.core.meta.PageUtil;
import com.mirage.core.utils.AppHttpClient;
import com.mirage.core.utils.BeanConvertUtil;
import com.mirage.core.utils.Constants;
import com.mirage.core.utils.GsonUtil;
import com.mirage.mirageservice.domain.*;
import com.mirage.mirageservice.enums.MinProgramConfigEnum;
import com.mirage.mirageservice.mapper.mysql.CsMinWechatUserMapper;
import com.mirage.mirageservice.mapper.mysql.StudentDataReportMapper;
import com.mirage.mirageservice.mapper.mysql.WechatBindMapper;
import com.mirage.mirageservice.mapper.sqlserver.ScanPageMapper;
import com.mirage.mirageservice.mapper.sqlserver.StudentMapper;
import com.mirage.mirageservice.meta.AppContext;
import com.mirage.mirageservice.meta.BindRequest;
import com.mirage.mirageservice.meta.StudentDataReportResponse;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.client.entity.EntityBuilder;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.entity.ContentType;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * Created by hzlinhai on 2025/1/2.
 */

@Service
@Slf4j
public class UserService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Resource
    private WechatService wechatService;
    @Resource
    private ScanPageMapper scanPageMapper;
    @Resource
    private StudentMapper studentMapper;
    @Resource
    private WechatBindMapper wechatBindMapper;
    @Resource
    private StudentDataReportMapper studentDataReportMapper;
    @Resource
    private CsMinWechatUserMapper csMinWechatUserMapper;

    public PageResultVo<StudentDataReportResponse> reportList(String openId, Integer pageIndex, Integer pageSize){
        WechatBind wechatBind = wechatBindMapper.selectOneByOpenid(openId);
        if(null == wechatBind){
            return new PageResultVo<>();
        }
        Student student = studentMapper.selectByPrimaryKey(wechatBind.getStudentid());
        if(null == student){
            return new PageResultVo<>();
        }
        PageHelper.startPage(pageIndex, pageSize);
        List<StudentDataReport> list = studentDataReportMapper.selectAllByStudentIdOrderByCreateTimeDescAndIdDesc(wechatBind.getStudentid().longValue());
        PageResultVo<StudentDataReportResponse> resultVo = PageUtil.convertPageResult(list, StudentDataReport.class, StudentDataReportResponse.class);
        for(StudentDataReportResponse reportResponse : resultVo.getList()){
            reportResponse.setStudentStage(student.getStudentstage());
        }
        return resultVo;
    }

    public StudentDataReport getReportDetail(Integer id){
        return studentDataReportMapper.selectByPrimaryKey(id);
    }
    public boolean unBind(BindRequest bindRequest){
        WechatBind wechatBind = wechatBindMapper.selectOneByOpenid(bindRequest.getOpenId());
        if(null == wechatBind){
            return true;
        }
        wechatBindMapper.deleteByPrimaryKey(wechatBind.getId());
        return true;
    }

    public BindRequest bind(BindRequest bindRequest){
        ScanPage scanPage = scanPageMapper.selectByPrimaryKey(bindRequest.getScanPageId());
        if(null == scanPage){
            throw new AppRuntimeException("未找到该筛查表编号");
        }
        Student student = studentMapper.selectByPrimaryKey(scanPage.getStudentid());
        if(null == student){
            throw new AppRuntimeException("姓名与学籍库不一致");
        }
        WechatBind wechatBind = wechatBindMapper.selectOneByOpenid(bindRequest.getOpenId());
        if(null == wechatBind){
            wechatBind.setStudentid(student.getId());
            wechatBind.setStudentname(student.getName());
            wechatBind.setPhone(bindRequest.getPhone());
            wechatBind.setCreatetime(new Date());
            wechatBind.setOpenid(bindRequest.getOpenId());
            wechatBindMapper.insertSelective(wechatBind);
        }
        BindRequest bindResponse = BeanConvertUtil.safeConvert(bindRequest, BindRequest.class, BindRequest.class);
        bindResponse.setStudentId(student.getId());
        bindResponse.setStudentName(wechatBind.getStudentname());
        return bindResponse;
    }

    public CsMinWechatUser wxLogin(String code, MinProgramConfigEnum configEnum){
        String phone = this.getPhoneNumberByCode(code, configEnum);
        if(StringUtils.isBlank(phone)){
            return null;
        }
        CsMinWechatUser wechatUser = csMinWechatUserMapper.selectOneByPhoneAndWechatAppIdAndIsDeleted(phone, configEnum.getAppId(), 0);
        if(null != wechatUser){
            String currentToken = wechatUser.getLoginToken();
            if(StringUtils.isNotBlank(currentToken)){
                String sessionValue = stringRedisTemplate.boundValueOps(Constants.REDIS_MIRAGE_LOGIN_SESSION + currentToken).get();
                if(StringUtils.isNotBlank(sessionValue)){
                    wechatUser.setLastLoginTime(System.currentTimeMillis());
                    csMinWechatUserMapper.updateByPrimaryKeySelective(wechatUser);
                    return wechatUser;
                }
                if(StringUtils.isBlank(sessionValue)){
                    currentToken = UUID.randomUUID().toString().replaceAll("-", "");;
                }
            }else{
                currentToken = UUID.randomUUID().toString().replaceAll("-", "");
            }
            wechatUser.setLoginToken(currentToken);
            wechatUser.setLastLoginTime(System.currentTimeMillis());
            csMinWechatUserMapper.updateByPrimaryKeySelective(wechatUser);
            this.getLoginSession(currentToken, wechatUser);
            return wechatUser;
        }
        wechatUser = new CsMinWechatUser();
        wechatUser.setPhone(phone);
        wechatUser.setWechatType(0);
        wechatUser.setWechatAppId(configEnum.getAppId());
        wechatUser.setIsDeleted(0);
        wechatUser.setCreateTime(System.currentTimeMillis());
        wechatUser.setModifiedTime(System.currentTimeMillis());
        String loginToken = UUID.randomUUID().toString().replaceAll("-", "");
        wechatUser.setLoginToken(loginToken);
        csMinWechatUserMapper.insertSelective(wechatUser);
        this.getLoginSession(loginToken, wechatUser);
        return wechatUser;
    }

    private String getLoginSession(String sessionKey, CsMinWechatUser wechatUser){
        if(StringUtils.isBlank(sessionKey) || null == wechatUser){
            return null;
        }
        stringRedisTemplate.boundValueOps(Constants.REDIS_MIRAGE_LOGIN_SESSION+sessionKey).set(GsonUtil.toJson(wechatUser), 7*86400, TimeUnit.SECONDS);
        return sessionKey;
    }

    public JsonObject getUserWxInfo(String code, MinProgramConfigEnum configEnum){
        if(StringUtils.isBlank(code)){
            return null;
        }
        CsMinWechatUser csMinWechatUser = AppContext.getUserInfo();
        if(null == csMinWechatUser){
            return null;
        }
        JsonObject weChatJo = wechatService.jscode2session(code, configEnum);
        if (null == weChatJo) {
            return null;
        }
        // 不返回Session_keys
        if (weChatJo.get("session_key") != null) {
            weChatJo.remove("session_key");
        }
        // 获取微信授权信息，回填用户表信息
        if(StringUtils.isBlank(csMinWechatUser.getOpenId()) && null != weChatJo.get("openid")){
            csMinWechatUser.setOpenId(weChatJo.get("openid").getAsString());
        }
        if(StringUtils.isBlank(csMinWechatUser.getUnionId()) && null != weChatJo.get("unionid")){
            csMinWechatUser.setUnionId(weChatJo.get("unionid").getAsString());
        }
        csMinWechatUser.setModifiedTime(System.currentTimeMillis());
        csMinWechatUserMapper.updateByPrimaryKeySelective(csMinWechatUser);
        return weChatJo;
    }

    public String getPhoneNumberByCode(String code, MinProgramConfigEnum programConfigEnum){
        if(StringUtils.isBlank(code)){
            return null;
        }
        String accessToken = this.getOrRefreshAccountToken(programConfigEnum);
        if(StringUtils.isBlank(accessToken)){
            return null;
        }
        Map<String, Object> param = Maps.newHashMap();
        param.put("code", code);
        RequestBuilder requestBuilder = RequestBuilder.post("https://api.weixin.qq.com/wxa/business/getuserphonenumber?access_token="+accessToken)
                .setEntity(EntityBuilder.create().setText(GsonUtil.toJson(param))
                        .setContentType(ContentType.create("application/json", "UTF-8")).build());
        try{
            String response = AppHttpClient.getInstance().execute(requestBuilder.build(), 5000);
            log.info("WechatService#getPhoneNumberByCode code:{}, response:{}", code, response);
            JsonObject jsonObject = GsonUtil.parseJsonObject(response);
            if(null == jsonObject
                    || null == jsonObject.get("errcode")
                    || jsonObject.get("errcode").getAsInt() != 0){
                return null;
            }
            JsonObject dataJo = GsonUtil.getJsonObject(jsonObject, "phone_info");
            if(null == dataJo || null == dataJo.get("phoneNumber")){
                return null;
            }
            return dataJo.get("phoneNumber").getAsString();
        }catch (Exception e){
            log.error("WechatService#getPhoneNumberByCode code:{}, err:{}", code, e.getMessage(), e);
        }
        return null;
    }

    public void deleteCache(){
        stringRedisTemplate.delete(Constants.REDIS_MIN_PROGRAM_ACCESS_TOKEN);
    }

    public String getOrRefreshAccountToken(MinProgramConfigEnum programConfigEnum){
        String accessToken = stringRedisTemplate.boundValueOps(Constants.REDIS_MIN_PROGRAM_ACCESS_TOKEN).get();
        if(StringUtils.isNotBlank(accessToken)){
            return accessToken;
        }
        accessToken = wechatService.requestAccessToken(0, programConfigEnum);
        stringRedisTemplate.boundValueOps(Constants.REDIS_MIN_PROGRAM_ACCESS_TOKEN).set(accessToken, 2, TimeUnit.HOURS);
        return accessToken;
    }

}