package cn.cslg.pas.service;

import cn.cslg.pas.common.model.vo.ProjectSharedTenantVO;
import cn.cslg.pas.common.model.vo.ProjectUsedByTenantVO;
import cn.cslg.pas.common.model.vo.TenantVo;
import cn.cslg.pas.domain.Project;
import cn.cslg.pas.domain.ProjectPatentLink;
import cn.cslg.pas.domain.ProjectUser;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @Author xiexiang
 * @Date 2023/7/28
 */
@RequiredArgsConstructor
@Slf4j
@Service
public class ProjectUsedByTenantService {
    @Value("${authorUrl}")
    private String PCSUrl;
    private final ProjectService projectService;
    private final ProjectPatentLinkService projectPatentLinkService;
    private final ProjectUserService projectUserService;

    /**
     * 查询租户专题库使用情况
     * @return
     * @throws IOException
     */
    public List<ProjectUsedByTenantVO> getProjectUsedByTenant(List<Integer> tenantIds) throws IOException {
        List<ProjectUsedByTenantVO> projectUsedByTenantVOS = new ArrayList<>();
        //获取租户id和名称的集合
        Map<Integer, String> tenantMap = this.getAllTenant(tenantIds);
        tenantMap.forEach((key, value)->{
            LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Project::getTenantId,key);
            //某一个租户id对应的专题库数量
            Long count = projectService.count(queryWrapper);
            Integer projectNum = Long.valueOf(count).intValue();
            //专题库名称
            List<Project> projects = projectService.list(queryWrapper);
            if(projects.size() > 0){//租户下有专题库
                //专题库id和名称组成map
                Map<Integer, String> projectMaps = projects.stream().collect(Collectors.toMap(Project::getId, Project::getName));
                //遍历
                projectMaps.forEach((key1,value1)->{
                    LambdaQueryWrapper<ProjectPatentLink> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(ProjectPatentLink::getProjectId,key1);
                    Long count1 = projectPatentLinkService.count(queryWrapper1);
                    Integer patentNum = Long.valueOf(count1).intValue();
                    ProjectUsedByTenantVO projectUsedByTenantVO = new ProjectUsedByTenantVO();
                    projectUsedByTenantVO.setTenantName(value);
                    projectUsedByTenantVO.setProjectNum(projectNum);
                    projectUsedByTenantVO.setProjectId(key1);
                    projectUsedByTenantVO.setProjectName(value1);
                    projectUsedByTenantVO.setPatentNum(patentNum);
                    projectUsedByTenantVOS.add(projectUsedByTenantVO);
                });
            } else {//租户下没有专题库
                ProjectUsedByTenantVO projectUsedByTenantVO = new ProjectUsedByTenantVO();
                projectUsedByTenantVO.setTenantName(value);
                projectUsedByTenantVO.setProjectNum(0);
                projectUsedByTenantVO.setProjectName(null);
                projectUsedByTenantVO.setPatentNum(0);
                projectUsedByTenantVOS.add(projectUsedByTenantVO);
            }
        });
        return projectUsedByTenantVOS;
    }

    /**
     * 查询所有租户
     * @return
     * @throws IOException
     */
    public Map<Integer, String> getAllTenant(List<Integer> tenantIds) throws IOException {
        //调用权限系统查询租户信息接口
        String str = this.getTenantFromPCS(tenantIds);
        Gson gson = new Gson();
        Type listType = new TypeToken<List<TenantVo>>(){}.getType();
        List<TenantVo> tenantVos = gson.fromJson(str, listType);
        Map<Integer,String> tenantMap = tenantVos.stream().collect(Collectors.toMap(TenantVo::getId, TenantVo::getTenantName));
        return tenantMap;
    }

    /**
     * 调用权限系统查询租户接口
     * @return
     * @throws IOException
     */
    public String getTenantFromPCS(List<Integer> tenantIds) throws IOException {
        String param = new Gson().toJson(tenantIds);
        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), param);
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(60, TimeUnit.SECONDS)
                .writeTimeout(60, TimeUnit.SECONDS)
                .readTimeout(60, TimeUnit.SECONDS)
                .build();
        Request request = new Request.Builder()
                .url(PCSUrl + "/permission/api/tenant/getTenantIdAndName")
                .post(requestBody)
                .build();
        return Objects.requireNonNull(okHttpClient.newCall(request).execute().body()).string();
    }

    /**
     * 查询租户被分享的专题库名
     * @return
     * @throws IOException
     */
    public List<ProjectSharedTenantVO> projectShared(List<Integer> tenantIds) throws IOException {
        List<ProjectSharedTenantVO> projectSharedTenantVOS = new ArrayList<>();
        //获取租户id和名称的集合
        Map<Integer, String> tenantMap = this.getAllTenant(tenantIds);
        //遍历
        tenantMap.forEach((key, value)->{
            //根据租户id查询分享库中的专题库信息集合
            LambdaQueryWrapper<ProjectUser> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProjectUser::getTenantId, key);
            List<ProjectUser> projectUsers = projectUserService.list(queryWrapper);
            //查询租户使用的专题库集合
            LambdaQueryWrapper<Project> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(Project::getTenantId, key);
//            List<Project> oldProjects = projectService.list(queryWrapper1);
            //租户使用的专题库ids
            List<Integer> oldProjectIds = projectService.list(queryWrapper1).stream().map(Project::getId).collect(Collectors.toList());
            //过滤出分享库中 不在租户使用的专题库ids集合 （过滤条件：租户名下使用的专题库ids中不包含分享库中的专题库ids，如果包含则过滤掉）
            List<Integer> ids = projectUsers.stream().filter(item -> !oldProjectIds.contains(item.getProjectId())).map(ProjectUser::getProjectId).collect(Collectors.toList());
            if(ids.size() > 0) {
                LambdaQueryWrapper<Project> queryWrapper2 = new LambdaQueryWrapper<>();
                queryWrapper2.in(Project::getId,ids);
                List<Project> projects = projectService.list(queryWrapper2);
                if(projects.size() > 0) {
                    //遍历专题库ids，取出专题库名称
                    for(int i = 0; i < projects.size(); i++){
                        ProjectSharedTenantVO projectSharedTenantVO = new ProjectSharedTenantVO();
                        //租户名为value
                        projectSharedTenantVO.setTenantName(value);
                        //被分享专题库数量为ids的长度
                        projectSharedTenantVO.setProjectNum(projects.size());
                        //专题库名
                        projectSharedTenantVO.setProjectName(projects.get(i).getName());
                        projectSharedTenantVOS.add(projectSharedTenantVO);
                    }
                } else {//ids不为0，但是数据库中没有，脏数据容错
                    ProjectSharedTenantVO projectSharedTenantVO = new ProjectSharedTenantVO();
                    //租户名为value
                    projectSharedTenantVO.setTenantName(value);
                    projectSharedTenantVO.setProjectNum(0);
                    projectSharedTenantVOS.add(projectSharedTenantVO);
                }
            } else {//专题库ids为0
                ProjectSharedTenantVO projectSharedTenantVO = new ProjectSharedTenantVO();
                //租户名为value
                projectSharedTenantVO.setTenantName(value);
                projectSharedTenantVO.setProjectNum(0);
                projectSharedTenantVOS.add(projectSharedTenantVO);
            }
        });
        return projectSharedTenantVOS;
    }
}