package com.estate.expert.admin.initdata;

import com.estate.expert.admin.service.*;
import com.estate.expert.admin.service.eval.EvalFuzzyService;
import com.estate.expert.admin.service.eval.EvalScoreService;
import com.estate.expert.admin.service.expert.DeviceExpertService;
import com.estate.expert.admin.service.expert.SysExpertService;
import com.estate.expert.admin.service.model.DeviceModelService;
import com.estate.expert.admin.service.model.MeasureModelService;
import com.estate.expert.admin.service.model.SystemModelService;
import com.estate.expert.admin.service.sign.ProjectSignService;
import com.estate.expert.admin.service.sign.WorkSignService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.IOException;

@Service
@Slf4j
public class SystemInitializer {

    @Resource
    private RoleService roleService;

    @Resource
    private UserService userService;

    @Resource
    private UserFileService userFileService;

    @Resource
    private ClientService clientService;

    @Resource
    private ContractService contractService;

    @Resource
    private CarService carService;

    @Resource
    private HierarchyService hierarchyService;

    @Resource
    private ProblemService problemService;

    @Resource
    private SystemModelService systemModelService;

    @Resource
    private DeviceModelService deviceModelService;

    @Resource
    private MeasureModelService measureModelService;

    @Resource
    private SysExpertService sysExpertService;

    @Resource
    private DeviceExpertService deviceExpertService;

    @Resource
    private PlanService planService;

    @Resource
    private ProjectService projectService;

    @Resource
    private CheckTaskService checkTaskService;

    @Resource
    private ErrorRecordService errorRecordService;

    @Resource
    private WarningRecordService warningRecordService;

    @Resource
    private DeviceService deviceService;

    @Resource
    private DeviceUsageService deviceUsageService;

    @Resource
    private ProjectInfoService projectInfoService;

    @Resource
    private ReportTemplateService reportTemplateService;

    @Resource
    private EvalFuzzyService evalFuzzyService;

    @Resource
    private EvalScoreService evalScoreService;

    @Resource
    private ArchiveService archiveService;

    @Resource
    private ProjectSignService projectSignService;

    @Resource
    private WorkSignService workSignService;

    @Resource
    private MeasureRuleService measureRuleService;

    public void importBusiness() {
        var importer = ImportBusinessJob.builder()
                .roleService(roleService)
                .userService(userService)
                .userFileService(userFileService)
                .archiveService(archiveService)
                .clientService(clientService)
                .contractService(contractService)
                .carService(carService)
                .deviceService(deviceService)
                .reportTemplateService(reportTemplateService)
                .build();
        importer.importRoles();
        importer.importUsers();
        importer.importSampleFiles();
        importer.importArchives();
        importer.importClients();
        importer.importContracts();
        importer.importCars();
        importer.importDevices();
        importer.importReportTemplates();
    }

    public void importHierarchy() {
        var importer = ImportHierarchyJob.builder()
                .userService(userService)
                .hierarchyService(hierarchyService)
                .build();

//        importer.importSystemHierarchyData();
//        importer.importDeviceHierarchyData();
        importer.importMeasureHierarchyData();
//        importer.importDepartments();
    }

    public void importProblem() {
        var importer = ImportProblemJob.builder()
                .userService(userService)
                .problemService(problemService)
                .hierarchyService(hierarchyService)
                .build();
        importer.testLoadProblem();
        importer.importAllProblem();
    }

    public void importMeasureRule() {
        var importer = ImportMeasureRuleJob.builder()
                .userService(userService)
                .hierarchyService(hierarchyService)
                .measureRuleService(measureRuleService)
                .build();
        importer.importMeasureRules();
    }

    public void importModel() {
        var importer = ImportModelJob.builder()
                .userService(userService)
                .hierarchyService(hierarchyService)
                .problemService(problemService)
                .systemModelService(systemModelService)
                .deviceModelService(deviceModelService)
                .measureModelService(measureModelService)
                .build();

        importer.createDefaultModels();
//        importer.importSystemModel();
    }

    public void importExpert() throws IOException {
        var importer = ImportExpertJob.builder()
                .deviceExpertService(deviceExpertService)
                .sysExpertService(sysExpertService)
                .userService(userService)
                .deviceModelService(deviceModelService)
                .systemModelService(systemModelService)
                .hierarchyService(hierarchyService)
                .build();

        importer.createDefaultExpert();
        importer.importSystemExpert();
    }

    public void importPlanAndProject() {
        var importer = ImportPlanAndProject.builder()
                .userService(userService)
                .deviceService(deviceService)
                .planService(planService)
                .projectService(projectService)
                .projectInfoService(projectInfoService)
                .deviceModelService(deviceModelService)
                .deviceExpertService(deviceExpertService)
                .systemModelService(systemModelService)
                .sysExpertService(sysExpertService)
                .deviceUsageService(deviceUsageService)
                .build();
        importer.importProjects();
        importer.importPlans();
        importer.importDeviceUsage();
    }

    public void importTaskAndRecord() {
        var importer = ImportTaskAndRecord.builder()
                .userService(userService)
                .checkTaskService(checkTaskService)
                .projectInfoService(projectInfoService)
                .errorRecordService(errorRecordService)
                .warningRecordService(warningRecordService)
                .problemService(problemService)
                .hierarchyService(hierarchyService)
                .deviceService(deviceService)
                .build();
        importer.importCheckTasks();
        importer.importProjectInfos();
        importer.importRecords();
        importer.importDeviceRecords();
        importer.importByPassInfo();
        importer.closeCheckTasks();
        importer.importReviewTasks();
        importer.importReviewRecords();
        importer.closeReviewTasks();
    }

    public void importEvalResult() {
        for(var checkTask : checkTaskService.findAll()) {
            log.info("Evaluating check task: {}, {}", checkTask.getId(), checkTask.getName());
            evalScoreService.eval(checkTask);
            evalFuzzyService.eval(checkTask);

            if(checkTask.getId()>20)
                break;
        }
    }

    public void importSignRecord() {
        var importer = ImportSignJob.builder()
                .userService(userService)
                .projectSignService(projectSignService)
                .workSignService(workSignService)
                .build();
        importer.importProjectSign();
        importer.importWorkSign();
    }
}