package com.enterprise.manage.modules.asset.controller;

import com.enterprise.manage.common.base.BaseController;
import com.enterprise.manage.common.constant.emuns.InstitutionNature;
import com.enterprise.manage.common.constant.emuns.OperationType;
import com.enterprise.manage.common.web.request.PageDomain;
import com.enterprise.manage.common.web.response.Result;
import com.enterprise.manage.common.web.response.module.ResultTable;
import com.enterprise.manage.core.annotation.Log;
import com.enterprise.manage.modules.asset.domain.Enterprise;
import com.enterprise.manage.modules.asset.service.IEnterpriseService;
import com.enterprise.manage.modules.system.domain.po.DictItem;
import com.enterprise.manage.modules.system.domain.po.Org;
import com.enterprise.manage.modules.system.domain.po.User;
import com.enterprise.manage.modules.system.service.IUserService;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 企业机构 Controller
 *
 * @author QingLi Wang
 * @version 1.0.0
 * 2023-11-28 09:24
 */
@RestController
@RequestMapping("/asset/enterprise/v1")
public class EnterpriseController extends BaseController {

    private IEnterpriseService enterpriseService;
    @Resource
    private IUserService userService;

    @Autowired
    public EnterpriseController(IEnterpriseService enterpriseService) {
        this.enterpriseService = enterpriseService;
    }

    @GetMapping
    public ResultTable list(PageDomain pageDomain, Enterprise param) {
        User currentUser = userService.queryById(getCurrentUser().getId());
        Org org = currentUser.getOrg();
        Enterprise userEnterprise = currentUser.getEnterprise();
        if (param.getId() != null || userEnterprise != null) {
            Long enterpriseId = param.getId() == null ? userEnterprise.getId() : param.getId();
            Enterprise enterprise = enterpriseService.queryById(enterpriseId);
            if (enterprise == null){
                return pageTableFailure(null, 0, String.format("企业不存在 %d",enterprise.getId()));
            }
            // 指定企业
            // 1、用户是否有权限
            // 2、查询企业信息和子属企业信息
            List<Enterprise> Enterprises = new ArrayList<>();
            Enterprises.add(enterprise);
            List<Enterprise> children = enterpriseService.getChildren(enterpriseId, Enterprises);
            List<Enterprise> collect = children.stream().filter(item -> {
                if (StringUtils.isNotBlank(param.getName()) && !StringUtils.containsAny(item.getName(), param.getName())) {
                    return false;
                }
                if (StringUtils.isNotBlank(param.getAddress()) && !StringUtils.containsAny(item.getAddress(), param.getAddress()))
                {
                    return false;
                }
                return true;
            }).collect(Collectors.toList());

            if (CollectionUtils.isEmpty(collect)) {
                return pageTable(new ArrayList<>(), 0);
            }
            int start = pageDomain.start();
            int size = collect.size() >= pageDomain.end() ? pageDomain.end() : pageDomain.end();
            List<Enterprise> data = collect.subList(start,size-1);
                return pageTable(data, data.size());
        } else if (org != null) {
            // 政府用户 只能看到本市、区的，其余的有企业触发。
            // 1、市级账户传市、区县级账户增加本区县，不区分等级
            if (org.getNature().equals(InstitutionNature.CITY_NATURE.getLabel())) {
            }   if (org.getNature().equals(InstitutionNature.AREA_NATURE.getLabel())) {
                // 2、区级账户只能查本区的
                param.setArea(org.getArea());
            } else {
                return pageTableFailure(null, 0, "组织账户性质不在设置范围内");
            }
            param.setEscalationStatus(true);
            PageInfo<Enterprise> enterprisePage = enterpriseService.page(pageDomain, param);
            return pageTable(enterprisePage.getList(), enterprisePage.getTotal());
        } else if ("admin".equals(currentUser.getUsername())) {
            // 管理员查看 一级企业不区分市、区县 1级企业为本市的企业
            param.setLevel(1);
            PageInfo<Enterprise> enterprisePage = enterpriseService.page(pageDomain, param);
            return pageTable(enterprisePage.getList(), enterprisePage.getTotal());
        }
        return pageTableFailure(null, 0, "查询数据不规范，请确认用户信息和查询条件");
    }


    @GetMapping("{id}")
    @PreAuthorize("hasPermission('','enterprise:enterprise:main')")
    public Result get(@PathVariable Long id) {
        return success(enterpriseService.queryById(id));
    }

    @GetMapping("selectTree")
    @PreAuthorize("hasPermission('','enterprise:anagement:main')")
    public Result selectTree() {
        return success(enterpriseService.querySelectTree());
    }

    @PostMapping
//    @PreAuthorize("hasPermission('','asset:enterprise:add')")
    @Log(operationType = OperationType.INSERT, title = "企业基本信息")
    public Result add(@RequestBody Enterprise enterprise) {
        // 1、检查参数
        String msg = checkAddParams(enterprise);
        if (StringUtils.isNotBlank(msg)) {
            return failure(msg);
        }
        // 2、唯一性检查
        if (enterpriseService.enterpriseUniqueCheck(enterprise.getCreditCode(), null)) {
            return failure("该企业已存在");
        }
        User currentUser = userService.queryById(getCurrentUser().getId());
        // 1\
        Org org = currentUser.getOrg();
        Enterprise userEnterprise = currentUser.getEnterprise();
        if (userEnterprise != null) {
            // 企业账号添加
            if (enterprise.getParentId() == null || enterprise.getParentId().equals(0L)) {
                return failure(String.format("企业不能创建一级企业,一级企业只能由政府部门创建"));
            }
            if (enterprise.getLevel() == null || enterprise.getLevel() <= 1L) {
                return failure(String.format("企业不能创建一级企业,一级企业只能由政府部门创建"));
            }
        } else if (org != null && org.getNature().equals(InstitutionNature.CITY_NATURE.getLabel())) {
            // 政府添加默认已审核完成
            if (enterprise.getParentId() != null && !enterprise.getParentId().equals(0L)) {
                return failure(String.format("组织账户只能创建一级企业,下属企业由企业自己创建"));
            }
            if (enterprise.getLevel() != null && enterprise.getLevel() != 1) {
                return failure(String.format("组织账户只能创建一级企业,下属企业由企业自己创建"));
            }
            if (!enterprise.getNature().equals(org.getNature())) {
                return failure(String.format("用户性质为：%s ，新增的企业性质为：%s 权限不一致", org.getNature(), enterprise.getNature()));
            }
            if (!org.getCity().getId().equals(enterprise.getCity().getId())) {
                return failure(String.format("组织账户创建企业必须是本市企业"));
            }
            enterprise.setArea(org.getArea());
            enterprise.setParentId(0L);
            // TODO:魔鬼数据
            enterprise.setExamineStatus(new DictItem(37L));

        } else if (org != null && org.getNature().equals(InstitutionNature.AREA_NATURE.getLabel())) {
            if (enterprise.getParentId() != null && !enterprise.getParentId().equals(0L)) {
                return failure(String.format("组织账户只能创建一级企业,下属企业由企业自己创建"));
            }
            if (enterprise.getLevel() != null && enterprise.getLevel() != 1) {
                return failure(String.format("组织账户只能创建一级企业,下属企业由企业自己创建"));
            }
            if (!enterprise.getNature().equals(org.getNature())) {
                return failure(String.format("用户性质为：%s ，新增的企业性质为：%s 权限不一致", org.getNature(), enterprise.getNature()));
            }
            if (!org.getCity().getId().equals(enterprise.getCity().getId())) {
                return failure(String.format("组织账户创建企业必须是本市企业"));
            }
            if (!org.getArea().getId().equals(enterprise.getArea().getId())) {
                return failure(String.format("组织账户本区县级创建企业必须是本区县企业"));
            }
            enterprise.setParentId(0L);
            // TODO:魔鬼数据
            enterprise.setExamineStatus(new DictItem(37L));
        } else if ("admin".equals(currentUser.getUsername())) {
            // 管理员新增
        } else {
            return failure("无法确认账户归属，请确认账户已绑定组织或者企业");
        }
        // 赋值操作
        if (enterprise.getParentId().equals(0L)) {
            enterprise.setLevel(1);
        } else {
            Enterprise parentEnterprise = enterpriseService.queryById(enterprise.getParentId());
            enterprise.setLevel(parentEnterprise.getLevel() + 1);
        }
        enterprise.insertConfigure();
        enterprise.updateConfigure();
        return decide(enterpriseService.save(enterprise));
    }

    @PutMapping
    @PreAuthorize("hasPermission('','asset:enterprise:edit')")
    @Log(operationType = OperationType.UPDATE, title = "企业基本信息")
    public Result edit(@RequestBody Enterprise enterprise) {
        return decide(enterpriseService.update(enterprise));
    }

    @DeleteMapping("{id}")
    @PreAuthorize("hasPermission('','asset:enterprise:del')")
    @Log(operationType = OperationType.DELETE, title = "企业基本信息")
    public Result remove(@PathVariable Integer id) {
        //  1、只有组织管理员（本市、本区）和本企业用户才能删除
        return decide(enterpriseService.removeById(id));
    }

    public String checkAddParams(Enterprise enterprise) {
        String msg = checkBaseParams(enterprise);
        if (StringUtils.isNotBlank(msg)) {
            return msg;
        }
        if (enterprise.getId() != null) {
            return "新增企业id存在，请确认参数";
        }
        return null;
    }

    private String checkBaseParams(Enterprise enterprise) {
        if (StringUtils.isBlank(enterprise.getCreditCode())) {
            return "社会信用代码 不能为空";
        }
        if (StringUtils.isBlank(enterprise.getName())) {
            return "企业名称 不能为空";
        }
        if (StringUtils.isBlank(enterprise.getLegalPerson())) {
            return "企业法人 不能为空";
        }
        if (StringUtils.isBlank(enterprise.getAddress())) {
            return "企业注册地址 不能为空";
        }
        if (enterprise.getNature() == null) {
            return "企业性质 不能为空";
        }
        if (enterprise.getCity() == null) {
            return "地区：市 不能为空";
        }
//        TODO: 市区县 字典
        if (enterprise.getNature().equals(InstitutionNature.AREA_NATURE.getLabel())) {
            if (enterprise.getArea() == null) {
                return "地区：区（县） 不能为空";
            }
        }
        return null;
    }

    public String checkEditParams(Enterprise enterprise) {
        if (enterprise.getId() == null) {
            return "请选择企业，在进行修改";
        }
        String msg = checkBaseParams(enterprise);
        if (StringUtils.isNotBlank(msg)) {
            return msg;
        }
        return null;
    }

}
