package com.ruoyi.web.controller.zhang;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.domain.*;
import com.ruoyi.domain.dto.AncestorClan;
import com.ruoyi.domain.dto.AncestorHelper;
import com.ruoyi.service.ZInfoUserService;
import com.ruoyi.service.ZfAncestorService;
import com.ruoyi.service.ZfFamilyService;
import com.ruoyi.system.domain.SysUserRole;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.mapper.SysUserRoleMapper;
import com.ruoyi.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;

import java.util.ArrayList;
import java.util.List;

import static com.ruoyi.common.core.domain.AjaxResult.error;
import static com.ruoyi.common.core.page.TableSupport.*;
//import static jdk.nashorn.internal.runtime.regexp.joni.Config.log;

@RestController
@RequestMapping("/ZfAncestor")
public class ZfAncestorController {
    @Autowired
    ZfAncestorService zfAncestorService;

    @Autowired
    private ISysUserService userService;

    @Autowired
    private SysUserMapper userMapper;

    @Resource
    ZInfoUserService zInfoUserService;

    @Resource
    private SysUserRoleMapper sysUserRoleMapper;

    @Resource
    private ZfFamilyService zfFamilyService;

    @GetMapping("/all/{clanId}")
    public AjaxResult listAll(@PathVariable Integer clanId){
        Integer pageNo = Convert.toInt(ServletUtils.getParameter(PAGE_NUM), 1);
        Integer pageSize = Convert.toInt(ServletUtils.getParameter(PAGE_SIZE), 10);
        return zfAncestorService.selectDataList(clanId, pageNo, pageSize);
    }
    @GetMapping("/all")
    public AjaxResult listAll(ZfAncestor zfAncestor){
        Integer pageNo = Convert.toInt(ServletUtils.getParameter(PAGE_NUM), 1);
        Integer pageSize = Convert.toInt(ServletUtils.getParameter(PAGE_SIZE), 10);
        return zfAncestorService.selectDataList(zfAncestor, pageNo, pageSize);
    }


    public Long addAncestor(ZfAncestor zfAncestor){

        SysUser us = new SysUser();
        us.setNickName(zfAncestor.getName());
        us.setStatus(String.valueOf(zfAncestor.getStatus()));
        us.setSex(String.valueOf(zfAncestor.getSex()));
        us.setPassword("123456");
        us.setUserName(zfAncestor.getName());

//        us.setUserId(Long.valueOf(zfAncestor.getSysId()));

        if (!userService.checkUserNameUnique(us))
        {
            throw new RuntimeException("新增祖先'" + us.getUserName() + "'失败，登录账号已存在");
        }
//        ZInfoUser myself = zInfoUserService.getMyself();
//        us.setCreateBy(myself.getNickName());
        us.setPassword(SecurityUtils.encryptPassword(us.getPassword()));
        userService.insertUser(us);

        SysUserRole sysUserRole = new SysUserRole();
        sysUserRole.setUserId(us.getUserId());
        sysUserRole.setRoleId(102L);
        List<SysUserRole> sysUserRoles = new ArrayList<>();
        sysUserRoles.add(sysUserRole);
        sysUserRoleMapper.batchUserRole(sysUserRoles);



        ZInfoUser infoUser = new ZInfoUser();
        infoUser.setClanId(zfAncestor.getClanId());
        infoUser.setSex(zfAncestor.getSex());
        infoUser.setNickName(zfAncestor.getName());
        infoUser.setSysId(us.getUserId());
        infoUser.setRoleId(zfAncestor.getRoleId().longValue());
        infoUser.setIsMyFamily(zfAncestor.getSex() == 0?1:0);
        infoUser.setSpouseId(zfAncestor.getSpouseId().longValue());

        zInfoUserService.save(infoUser);
        if(zfAncestor.getSpouseId()!=null)
        {
            ZInfoUser zu = new ZInfoUser();
            zu.setUserId(Long.valueOf(zfAncestor.getSpouseId()));
            zu.setSpouseId(infoUser.getUserId());
            zInfoUserService.updateById(zu);
        }
        return us.getUserId();
    }

    public void updateAncestor(ZfAncestor zfAncestor){
        SysUser us = new SysUser();
        Long userId = zInfoUserService.getInfoBysysId(zfAncestor.getSysId()).getUserId();
        us.setUserId(zfAncestor.getSysId());

        us.setUserName(zfAncestor.getName());
        us.setNickName(zfAncestor.getName());
        us.setSex(String.valueOf(zfAncestor.getSex()));
//        us.setRemark(zfAncestor.getRemark());
        userService.updateUser(us);

        Long userId1 = zfAncestor.getSysId();
        SysUserRole sysUserRole=sysUserRoleMapper.selectUserById(userId1);
        //      System.out.println(user.getFamilyId());
        //   System.out.println("[[[[]]]]]]");
        ZInfoUser infoUser = new ZInfoUser();
        infoUser.setUserId(userId);
        infoUser.setOldName(zfAncestor.getName());
        infoUser.setNickName(zfAncestor.getName());

        infoUser.setSex(zfAncestor.getSex());
//        infoUser.setFamilyId(user.getFamilyId());
        infoUser.setSysId(zfAncestor.getSysId());

        zInfoUserService.updateById(infoUser);
    }
    @Log(title = "家庭大事件记录", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, ZfAncestor zfAncestor) {
        List<AncestorClan> list = new ArrayList<>();

        list = zfAncestorService.selectByCondition(zfAncestor);
       // log.info("导出记录为:{}", list);
        ExcelUtil<AncestorClan> util = new ExcelUtil<>(AncestorClan.class);
        util.exportExcel(response, list, "祖先记录数据");

    }
    /**
     * 导出导出祖先信息记录列表
     */
//    @PreAuthorize("@ss.hasPermi('system:property:export')")
    @Log(title = "导出祖先信息", businessType = BusinessType.EXPORT)
    @PostMapping("/export1/{ids}")
    public void export(HttpServletResponse response, @PathVariable Long[] ids)
    {
        List<AncestorClan> list = zfAncestorService.selectByIds(ids);
      //  log.info("导出记录为:{}",list);
        ExcelUtil<AncestorClan> util = new ExcelUtil<>(AncestorClan.class);
        util.exportExcel(response, list, "祖先记录数据");
    }



    /**
     * 修改祖先信息
     */
    @Log(title = "祖先", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody AncestorHelper ancestorHelper) {

//        ZfAncestor spouseSex = zfAncestorService.update(zfAncestor);
//        updateAncestor(zfAncestor);
//        if (spouseSex.getId() != null)
//        updateAncestor(spouseSex);

        //修改sys_user表
        SysUser us = new SysUser();
        if (ancestorHelper.getName() != null) {
            us.setNickName(ancestorHelper.getName());
            us.setUserName(ancestorHelper.getName());
            //   us.setStatus(String.valueOf(zfAncestor.getStatus()));
        }
        if(ancestorHelper.getSex() != null)
            us.setSex(String.valueOf(ancestorHelper.getSex()));

//        us.setClanId(ancestorHelper.getClanId());
        us.setUserId(ancestorHelper.getSysId());

        if (!userService.checkNickNameUnique(us)) {
            return error("修改祖先'" + us.getNickName() + "'失败，登录账号已存在");
        }
        userService.updateUser(us);


        //修改z_info_user表
        ZInfoUser infoUser = new ZInfoUser();
        infoUser.setSysId(us.getUserId());
        if (ancestorHelper.getName() != null) {
            infoUser.setNickName(us.getNickName());
            infoUser.setOldName(us.getUserName());
        }
        if(ancestorHelper.getSex() != null)
            infoUser.setSex(Integer.parseInt(us.getSex()));
        ZInfoUser infoBysysId = zInfoUserService.getInfoBysysId(us.getUserId());
        infoUser.setUserId(infoBysysId.getUserId());

        zInfoUserService.saveOrUpdate(infoUser);

        //修改zf_ancestor表
        ZfAncestor zfAncestor = new ZfAncestor();
//        zfAncestor.setClanId(ancestorHelper.getClanId());
        if (ancestorHelper.getName() != null)
        zfAncestor.setName(ancestorHelper.getName());
        if(ancestorHelper.getSex() != null)
        zfAncestor.setSex(ancestorHelper.getSex());
        zfAncestor.setSysId(ancestorHelper.getSysId());

        zfAncestorService.update(zfAncestor);

        return  AjaxResult.success();
    }


    /**
     * 新增祖先
     */
    @Log(title = "祖先", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody AncestorHelper ancestorHelper)
    {
        //保存祖先
        System.out.println(ancestorHelper);
        System.out.println("+++++++++++------------+++++++++");
        if(ancestorHelper.getRoleId()==4) {

            //新增一个默认的家庭号
            ZfFamily zfFamily = new ZfFamily();
            zfFamily.setName("默认一号家庭"+ancestorHelper.getClanId());
            zfFamily.setFid(0L);
            zfFamily.setMid(0L);
            zfFamily.setClanId(ancestorHelper.getClanId());
            zfFamilyService.addFamily(zfFamily);



            //写入sys_user表,其中的一个祖先
            SysUser us = new SysUser();
            us.setNickName(ancestorHelper.getName());
            //   us.setStatus(String.valueOf(zfAncestor.getStatus()));
            us.setSex(String.valueOf(ancestorHelper.getSex()));
            us.setPassword("123456");
            us.setUserName(ancestorHelper.getName());
            us.setClanId(ancestorHelper.getClanId());
            if (!userService.checkNickNameUnique(us)) {
                return error("新增祖先'" + us.getNickName() + "'失败，登录账号已存在");
            }

            us.setPassword(SecurityUtils.encryptPassword(us.getPassword()));
            userService.insertUser(us);
            //写入sys_user表,另外一个祖先
            SysUser usa = new SysUser();
            usa.setNickName(ancestorHelper.getFname());
            //   us.setStatus(String.valueOf(zfAncestor.getStatus()));
            usa.setSex(String.valueOf(ancestorHelper.getFsex()));
            usa.setPassword("123456");
            usa.setClanId(ancestorHelper.getClanId());
            usa.setUserName(ancestorHelper.getFname());
            if (!userService.checkNickNameUnique(usa)) {
                return error("新增祖先1'" + usa.getNickName() + "'失败，登录账号已存在");
            }

            us.setPassword(SecurityUtils.encryptPassword(usa.getPassword()));
            userService.insertUser(usa);



            //写入到z_info_user表
            ZInfoUser infoUser = new ZInfoUser();
            infoUser.setSysId(us.getUserId());
            //   infoUser.setUserId(user.getUserId());
            infoUser.setNickName(us.getNickName());
            infoUser.setOldName(us.getUserName());
//            infoUser.setPhoneNumber(userAll.getPhonenumber());
            infoUser.setSex(Integer.parseInt(us.getSex()));
            infoUser.setFatherId(0L);
            infoUser.setMomId(0L);
            infoUser.setIsMyFamily(1);
            infoUser.setFamilyId(zfFamily.getId());
            //少一个familyId

            //家族id
            infoUser.setClanId(ancestorHelper.getClanId());
            infoUser.setRoleId(3L);
            zInfoUserService.save(infoUser);



            //另外一个祖先写入z_info_user
            ZInfoUser infoUsera = new ZInfoUser();
            infoUsera.setSysId(usa.getUserId());
            //   infoUser.setUserId(user.getUserId());
            infoUsera.setNickName(usa.getNickName());
            infoUsera.setOldName(usa.getUserName());
//            infoUser.setPhoneNumber(userAll.getPhonenumber());
            infoUsera.setSex(Integer.parseInt(usa.getSex()));
            infoUsera.setFatherId(0L);
            infoUsera.setMomId(0L);
            infoUsera.setIsMyFamily(1);
            //少一个familyId
            infoUsera.setFamilyId(zfFamily.getId());
            //家族id
            infoUsera.setClanId(ancestorHelper.getClanId());
            infoUsera.setRoleId(3L);
            infoUsera.setSpouseId(infoUser.getUserId());
            zInfoUserService.save(infoUsera);


            //更新第一个祖先的配偶信息
            infoUser.setSpouseId(infoUsera.getUserId());
            zInfoUserService.saveOrUpdate(infoUser);


            //保存祖先信息到zfAncestor
            ZfAncestor zfAncestor = new ZfAncestor();
            zfAncestor.setClanId(ancestorHelper.getClanId());
            zfAncestor.setName(ancestorHelper.getName());
            zfAncestor.setSex(ancestorHelper.getSex());
            zfAncestor.setRoleId(4);
            zfAncestor.setPassword(SecurityUtils.encryptPassword("123456"));
            zfAncestor.setStatus(0);
            zfAncestor.setSysId(us.getUserId());
            zfAncestorService.addData(zfAncestor);

            //保存另外一个祖先信息
            ZfAncestor zfAncestor1 = new ZfAncestor();
            zfAncestor1.setClanId(ancestorHelper.getClanId());
            zfAncestor1.setName(ancestorHelper.getFname());
            zfAncestor1.setSex(ancestorHelper.getFsex());
            zfAncestor1.setRoleId(4);
            zfAncestor1.setPassword(SecurityUtils.encryptPassword("123456"));
            zfAncestor1.setStatus(0);
            zfAncestor1.setSysId(usa.getUserId());
            zfAncestorService.addData(zfAncestor1);
        }
        else{
            //保存祖先管理员,也先保存到sys_user
            SysUser us = new SysUser();
            us.setNickName(ancestorHelper.getName());
            //   us.setStatus(String.valueOf(zfAncestor.getStatus()));
            us.setSex(String.valueOf(ancestorHelper.getSex()));
            us.setPassword("123456");
            us.setUserName(ancestorHelper.getName());
            us.setClanId(ancestorHelper.getClanId());
            System.out.println(ancestorHelper.getClanId());
            System.out.println("0000_______+++++++++++++999999999999");
            if (!userService.checkNickNameUnique(us)) {
                return error("新增祖先管理员'" + us.getNickName() + "'失败，登录账号已存在");
            }

            us.setPassword(SecurityUtils.encryptPassword(us.getPassword()));
            userService.insertUser(us);


            //写到用户与角色对应的表
            SysUserRole sysUserRole = new SysUserRole();
            sysUserRole.setUserId(us.getUserId());
            sysUserRole.setRoleId(1L);
            List<SysUserRole> sysUserRoles = new ArrayList<>();
            sysUserRoles.add(sysUserRole);
            sysUserRoleMapper.batchUserRole(sysUserRoles);


            //保存祖先信息到zfAncestor
            ZfAncestor zfAncestor = new ZfAncestor();
            zfAncestor.setClanId(ancestorHelper.getClanId());
            zfAncestor.setName(ancestorHelper.getName());
            zfAncestor.setSex(ancestorHelper.getSex());
            zfAncestor.setRoleId(2);
            zfAncestor.setPassword(SecurityUtils.encryptPassword("123456"));
            zfAncestor.setStatus(0);
            zfAncestor.setSysId(us.getUserId());

            zfAncestorService.addData(zfAncestor);

        }


        return AjaxResult.success();
    }


//    /**
//     * 批量删除家族成员
//     */
//    @Log(title = "家族管理", businessType = BusinessType.DELETE)
//    @DeleteMapping("/{clanId}/{id}")
//    public AjaxResult remove(@PathVariable Integer id, @PathVariable Integer clanId) {
//        return zfAncestorService.deleteData(clanId,id);
//    }
}