package com.tuoheng.admin.service.structure;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tuoheng.admin.entity.*;
import com.tuoheng.admin.enums.DataPermissionEnum;
import com.tuoheng.admin.enums.SectionEnum;
import com.tuoheng.admin.enums.StructureEnum;
import com.tuoheng.admin.mapper.*;
import com.tuoheng.admin.query.StructureQuery;
import com.tuoheng.admin.utils.CurrentUserUtil;
import com.tuoheng.admin.vo.StructureInfoVo;
import com.tuoheng.common.core.common.BaseServiceImpl;
import com.tuoheng.common.core.config.common.CommonConfig;
import com.tuoheng.common.core.enums.ServiceExceptionEnum;
import com.tuoheng.common.core.exception.ServiceException;
import com.tuoheng.common.core.utils.CommonUtils;
import com.tuoheng.common.core.utils.DateUtils;
import com.tuoheng.common.core.utils.JsonResult;
import com.tuoheng.common.core.utils.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author ChengWang
 * @Date 2022/11/17
 */
@Service
public class StructureServiceImpl extends BaseServiceImpl<StructureMapper, Structure> implements IStructureService {

    @Autowired
    private StructureMapper structureMapper;

    @Autowired
    private SectionMapper sectionMapper;

    @Autowired
    private RoadInformationMapper roadInformationMapper;

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private DeptMapper deptMapper;

    @Autowired
    private SectionDeptMapper sectionDeptMapper;

    @Override
    public JsonResult queryPage(StructureQuery query) {
        if (null == (query.getPage()) && null == query.getLimit()) {
            throw new ServiceException(ServiceExceptionEnum.PARAMETER_IS_NULL);
        }
        //获取登录信息
        User user = CurrentUserUtil.getUserInfo();
        if (ObjectUtil.isNull(user)) {
            throw new ServiceException(ServiceExceptionEnum.PARAMETER_IS_NULL);
        }
        //租户id
        String tenantId = user.getTenantId();
        query.setTenantId(tenantId);

        IPage<StructureInfoVo> pageData = null;
        IPage<Structure> page = new Page<>(query.getPage(), query.getLimit());
        // 所有部门权限
        if (DataPermissionEnum.ALL.getCode() == user.getDataPermission()) {
            //数据分页
            pageData = structureMapper.queryPage(page, query);
            List<StructureInfoVo> list = pageData.getRecords().stream().map((item) -> {
                StructureInfoVo structureInfoVo = new StructureInfoVo();
                BeanUtils.copyProperties(item, structureInfoVo);
                //获取构造物图片，对图片进行处理
                if (StringUtils.isNotEmpty(item.getImageUrl())) {
                    String[] imageUrls = item.getImageUrl().split(",");
                    if (StringUtils.isNotEmpty(imageUrls)) {
                        for (int i = 0; i < imageUrls.length; i++) {
                            if (StringUtils.isNotEmpty(imageUrls[i])) {
                                imageUrls[i] = CommonConfig.imageURL + imageUrls[i];
                            }
                        }
                    }
                    structureInfoVo.setImageUrl(StringUtils.join(imageUrls, ","));
                }
//            if (StringUtils.isNotEmpty(item.getImageUrl())) {
//                String imageUrl = getMultipleUrl(item.getImageUrl());
//                structureInfoVo.setImageUrl(imageUrl);
//            }
                return structureInfoVo;
            }).collect(Collectors.toList());
            pageData.setRecords(list);
        }
        // 本部门及下属部门、本部门
        else if (DataPermissionEnum.DEPT_AND_SUB_DEPT.getCode() == user.getDataPermission()
                || DataPermissionEnum.DEPT.getCode() == user.getDataPermission()) {
            // 所在部门
            String deptId = user.getDeptId();
            if (StringUtils.isEmpty(deptId)) {
                return JsonResult.error(SectionEnum.DEPT_IS_NOT_EXIST.getCode(), SectionEnum.DEPT_IS_NOT_EXIST.getMsg());
            }
            List<String> deptList = new ArrayList<>();
            // 本部门及子部门权限
            if (DataPermissionEnum.DEPT_AND_SUB_DEPT.getCode() == user.getDataPermission()) {
                List<String> deptAndSubList = deptMapper.selectAllChildListById(deptId);
                if (StringUtils.isEmpty(deptAndSubList) && deptAndSubList.size() <= 0) {
                    return JsonResult.error(SectionEnum.DEPT_ID_IS_NULL.getCode(), SectionEnum.DEPT_ID_IS_NULL.getMsg());
                }
                deptList.addAll(deptAndSubList);
            }
            // 本部门权限
            else {
                deptList.add(deptId);
            }
            //获取当前登录用户对应的部门及子部门
            if (StringUtils.isEmpty(deptList) && deptList.size() <= 0) {
                return JsonResult.error(SectionEnum.DEPT_ID_IS_NULL.getCode(), SectionEnum.DEPT_ID_IS_NULL.getMsg());
            }
            //根据部门列表查对应的部门路段数据列表
            List<SectionDept> sectionDeptList = sectionDeptMapper.selectList(Wrappers.<SectionDept>lambdaQuery()
                    .eq(SectionDept::getTenantId, tenantId)
                    .in(SectionDept::getDeptId, deptList));
            if (StringUtils.isEmpty(sectionDeptList) && sectionDeptList.size() <= 0) {
                return JsonResult.error(SectionEnum.DEPT_SECTION_IS_NOT_EXIST.getCode(), SectionEnum.DEPT_SECTION_IS_NOT_EXIST.getMsg());
            }
            //查询对应的路段列表
            List<String> sectionIdList = sectionDeptList.stream().map(t -> t.getSectionId()).distinct().collect(Collectors.toList());
            if (StringUtils.isEmpty(sectionIdList)) {
                return JsonResult.error(SectionEnum.SECTION_ID_IS_NULL.getCode(), SectionEnum.SECTION_ID_IS_NULL.getMsg());
            }
            List<StructureInfoVo> list = new ArrayList<>();
            //根据路段id查询对应的构造物列表
            for (String sectionId : sectionIdList) {
                query.setSectionId(sectionId);
                pageData = structureMapper.queryPageBySectionId(page, query);
                List<StructureInfoVo> records = pageData.getRecords();
                for (StructureInfoVo record : records) {
                    //获取构造物图片，对图片进行处理
                    if (StringUtils.isNotEmpty(record.getImageUrl())) {
                        String[] imageUrls = record.getImageUrl().split(",");
                        if (StringUtils.isNotEmpty(imageUrls)) {
                            for (int i = 0; i < imageUrls.length; i++) {
                                if (StringUtils.isNotEmpty(imageUrls[i])) {
                                    imageUrls[i] = CommonConfig.imageURL + imageUrls[i];
                                }
                            }
                        }
                        record.setImageUrl(StringUtils.join(imageUrls, ","));
                    }
                    list.add(record);
                }
            }
            pageData.setRecords(list);
        }
        return JsonResult.success(pageData);
    }

    @Override
    public JsonResult getListInfo(StructureQuery query) {
        List<Structure> structureList = structureMapper.selectList(new LambdaQueryWrapper<Structure>()
                .eq(Structure::getMark, 1)
                .orderByDesc(Structure::getCreateTime));

        return JsonResult.success(structureList);
    }

    @Override
    public JsonResult editInfo(Structure entity) {
        //获取登录信息
        String userId = CurrentUserUtil.getUserId();
        if (StringUtils.isEmpty(userId)) {
            JsonResult.error(StructureEnum.USER_ID_IS_NULL.getCode(), StructureEnum.USER_ID_IS_NULL.getMsg());
        }

        //校验
        if (StringUtils.isEmpty(entity.getRoadId()) && StringUtils.isEmpty(entity.getSectionId())) {
            return JsonResult.error("公路和路段为空");
        }
        //获取租户id
        String tenantId = CurrentUserUtil.getTenantId();
        //查询用户信息
        if (StringUtils.isEmpty(entity.getId())) {
            //新增
            entity.setCreateTime(DateUtils.now());
            entity.setCreateUser(userId);
            entity.setTenantId(tenantId);
        } else {
            //更新
            entity.setUpdateTime(DateUtils.now());
            entity.setUpdateUser(userId);
            entity.setTenantId(tenantId);
        }
        super.edit(entity);

        return JsonResult.success();
    }

    /**
     * 当前登录人对应的公路所属的构造物
     *
     * @return
     */
    @Override
    public JsonResult getSectionInfo() {
        //获取登录信息
        User user = CurrentUserUtil.getUserInfo();
        if (ObjectUtil.isNull(user)) {
            throw new ServiceException(ServiceExceptionEnum.PARAMETER_IS_NULL);
        }
        user.setDataPermission(3);
        //获取登录信息
        String tenantId = user.getTenantId();
        if (StringUtils.isEmpty(tenantId)) {
            JsonResult.error(StructureEnum.TENANT_ID_IS_NULL.getCode(), StructureEnum.TENANT_ID_IS_NULL.getMsg());
        }
        List<Structure> structures = null;
        // 所有部门权限
        if (DataPermissionEnum.ALL.getCode() == user.getDataPermission()) {
            structures = structureMapper.selectList(Wrappers.<Structure>lambdaQuery().eq(Structure::getMark, 1)
                    .eq(Structure::getTenantId, tenantId));
        }
        // 本部门及下属部门、本部门
        else if (DataPermissionEnum.DEPT_AND_SUB_DEPT.getCode() == user.getDataPermission()
                || DataPermissionEnum.DEPT.getCode() == user.getDataPermission()) {
            String deptId = user.getDeptId();
            if (StringUtils.isEmpty(deptId)) {
                return JsonResult.error(SectionEnum.DEPT_IS_NOT_EXIST.getCode(), SectionEnum.DEPT_IS_NOT_EXIST.getMsg());
            }
            List<String> deptIdList = new ArrayList<>();
            // 本部门及下属部门
            if (DataPermissionEnum.DEPT_AND_SUB_DEPT.getCode() == user.getDataPermission()) {
                List<String> deptAndSubList = deptMapper.selectAllChildListById(deptId);
                if (StringUtils.isEmpty(deptAndSubList) && deptAndSubList.size() <= 0) {
                    return JsonResult.error(SectionEnum.DEPT_ID_IS_NULL.getCode(), SectionEnum.DEPT_ID_IS_NULL.getMsg());
                }
                deptIdList.addAll(deptAndSubList);
            }
            // 本部门
            else {
                deptIdList.add(deptId);
            }
            // 相关路段
            List<SectionDept> sectionDeptList = sectionDeptMapper.selectList(Wrappers.<SectionDept>lambdaQuery()
                    .eq(SectionDept::getTenantId, tenantId)
                    .in(SectionDept::getDeptId, deptIdList));
            if (StringUtils.isEmpty(sectionDeptList) && sectionDeptList.size() <= 0) {
                return JsonResult.error(SectionEnum.DEPT_SECTION_IS_NOT_EXIST.getCode(), SectionEnum.DEPT_SECTION_IS_NOT_EXIST.getMsg());
            }
            //查询对应的路段ID
            List<String> sectionIdList = sectionDeptList.stream().map(t -> t.getSectionId()).distinct().collect(Collectors.toList());
            if (StringUtils.isEmpty(sectionIdList)) {
                return JsonResult.error(SectionEnum.SECTION_ID_IS_NULL.getCode(), SectionEnum.SECTION_ID_IS_NULL.getMsg());
            }
            structures = structureMapper.selectList(Wrappers.<Structure>lambdaQuery()
                    .eq(Structure::getMark, 1)
                    .eq(Structure::getTenantId, tenantId)
                    .in(Structure::getSectionId, sectionIdList)
            );
        }

        if (null == structures) {
            return JsonResult.error();
        }
        List<StructureInfoVo> list = new ArrayList<>();
        for (Structure structure : structures) {
            StructureInfoVo structureInfoVo = new StructureInfoVo();
            BeanUtils.copyProperties(structure, structureInfoVo);
            //设置图片
            if (StringUtils.isNotEmpty(structure.getImageUrl())) {
                String[] imageUrls = structure.getImageUrl().split(",");
                if (StringUtils.isNotEmpty(imageUrls)) {
                    for (int i = 0; i < imageUrls.length; i++) {
                        if (StringUtils.isNotEmpty(imageUrls[i])) {
                            imageUrls[i] = CommonConfig.imageURL + imageUrls[i];
                        }
                    }
                }
                structureInfoVo.setImageUrl(StringUtils.join(imageUrls, ","));
            }
            //根据公路id获取公路code
            if (StringUtils.isEmpty(structure.getRoadId())) {
                throw new ServiceException(ServiceExceptionEnum.PARAMETER_IS_NULL);
            }
            RoadInformation roadInformation = roadInformationMapper.selectById(structure.getRoadId());
            if (ObjectUtil.isNotNull(roadInformation)) {
                structureInfoVo.setCode(roadInformation.getCode());
            }
            //根据路段id获取路段范围
            if (StringUtils.isEmpty(structure.getSectionId())) {
                throw new ServiceException(ServiceExceptionEnum.PARAMETER_IS_NULL);
            }
            Section section = sectionMapper.selectById(structure.getSectionId());
            if (ObjectUtil.isNotNull(section)) {
                structureInfoVo.setSectionRange(section.getSectionRange());
            }
            list.add(structureInfoVo);
        }

        return JsonResult.success(list);
    }


    /**
     * 多个url进行转换,用,号隔开
     *
     * @param url
     * @return
     */
    private String getMultipleUrl(String url) {

        List<String> collect = Arrays.asList(url.split(",")).stream().map(
                s -> CommonUtils.getImageURL(s)).collect(Collectors.toList());
        //返回
        return org.apache.commons.lang3.StringUtils.join(collect, ",");
    }
}
