package com.vcarecity.publish.controller;

import com.vcarecity.publish.annotation.SkipMethod;
import com.vcarecity.publish.api.ApiResult;
import com.vcarecity.publish.api.ApiStatus;
import com.vcarecity.publish.elastic.service.ElasticLoadDataService;
import com.vcarecity.publish.elastic.service.ElasticUpdateService;
import com.vcarecity.publish.entity.UnitAgencyMergeEntity;
import com.vcarecity.publish.pojo.dto.TotalResultDTO;
import com.vcarecity.publish.pojo.dto.UnitAgencyDTO;
import com.vcarecity.publish.pojo.dto.UnitIdDTO;
import com.vcarecity.publish.pojo.query.UnitAgencyQuery;
import com.vcarecity.publish.service.LoadDataStatusService;
import com.vcarecity.publish.sql.service.AgencyService;
import com.vcarecity.publish.sql.service.UnitService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Kerry on 19/12/11
 */

@Slf4j
@RestController
public class MainController implements PrepareController {


    private final UnitService unitService;
    private final AgencyService agencyService;
    private final ElasticLoadDataService elasticLoadDataService;
    private final ElasticUpdateService elasticUpdateService;
    private final LoadDataStatusService loadDataStatusService;

    @Value("${app.index.name}")
    private String indexName;

    public MainController(UnitService unitService,
                          ElasticLoadDataService elasticLoadDataService,
                          LoadDataStatusService loadDataStatusService,
                          @Value("${app.index.reload}") Boolean reloadData, AgencyService agencyService, ElasticUpdateService elasticUpdateService) {
        this.unitService = unitService;
        this.elasticLoadDataService = elasticLoadDataService;
        this.loadDataStatusService = loadDataStatusService;
        this.agencyService = agencyService;
        this.elasticUpdateService = elasticUpdateService;

        if (!reloadData) {
            // 不重新加载
            loadDataStatusService.setStatus(LoadDataStatusService.DATA_STATUS_LOADED);
        }
    }


    @SkipMethod
    @ResponseBody
    @RequestMapping(value = "/set-load", method = {RequestMethod.GET, RequestMethod.POST})
    public ApiResult setLoaded() {
        loadDataStatusService.setStatus(LoadDataStatusService.DATA_STATUS_LOADED);
        return ApiResult.builder().status(20000).message("already load data success!").build();
    }


    @SkipMethod
    @ResponseBody
    @RequestMapping(value = "/load", method = {RequestMethod.GET, RequestMethod.POST})
    public ApiResult loadData() {
        synchronized (this) {
            if (loadDataStatusService.getStatus() == LoadDataStatusService.DATA_STATUS_NOT_LOAD) {
                logger.info("prepare to load data into elasticsearch");
                loadDataStatusService.setStatus(LoadDataStatusService.DATA_STATUS_LOADING);
                new Thread(() -> {
                    try {
                        elasticLoadDataService.loadData();
                        loadDataStatusService.setStatus(LoadDataStatusService.DATA_STATUS_LOADED);
                    } catch (IOException e) {
                        e.printStackTrace();
                        loadDataStatusService.setStatus(LoadDataStatusService.DATA_STATUS_NOT_LOAD);
                    }
                }).start();
                return ApiResult.builder().status(40000).message("first load data into elasticsearch").build();
            } else if (loadDataStatusService.getStatus() == LoadDataStatusService.DATA_STATUS_LOADING) {
                return ApiResult.builder().status(40000).message("loading data into elasticsearch").build();
            }
        }
        return ApiResult.builder().status(20000).message("already load data success!").build();
    }

    private List<Long> toQueryIds(String idStr) {
        String[] split = idStr.split(",");
        List<Long> ids = new ArrayList<>(split.length);
        for (String s : split) {
            try {
                ids.add(Long.parseLong(s));
            } catch (RuntimeException e) {
                e.printStackTrace();
            }
        }
        return ids;
    }

    @ResponseBody
    @RequestMapping(value = "/loadByAgencyIds", method = {RequestMethod.POST, RequestMethod.GET})
    public ApiResult loadByAgencyIds(@RequestParam("agencyIds") String agencyIds) {
        List<Long> ids = toQueryIds(agencyIds);

        List<UnitAgencyMergeEntity> result = agencyService.loadByAgencyIds(ids);
        if (result == null) {
            return ApiResult.builder().status(ApiStatus.FAILED_CODE).build();
        }
        try {
            elasticUpdateService.handlerDataChange("unitId", result);
            return ApiResult.builder().status(ApiStatus.SUCCESS_CODE).build();
        } catch (IOException e) {
            e.printStackTrace();
            return ApiResult.builder().status(40000).message(e.getMessage()).build();
        }
    }

    @ResponseBody
    @RequestMapping(value = "/loadByUnitIds", method = {RequestMethod.POST, RequestMethod.GET})
    public ApiResult loadByUnitIds(@RequestParam("unitIds") String unitIds) {
        List<Long> ids = toQueryIds(unitIds);
        List<UnitAgencyMergeEntity> result = unitService.loadByUnitIds(ids);
        if (result == null || result.isEmpty()) {
            return ApiResult.builder().status(ApiStatus.FAILED_CODE).build();
        }
        try {
            elasticUpdateService.handlerDataChange("unitId", result);
            return ApiResult.builder().status(ApiStatus.SUCCESS_CODE).build();
        } catch (IOException e) {
            e.printStackTrace();
            return ApiResult.builder().status(40000).message(e.getMessage()).build();
        }
    }


    @PostMapping("/query-unit-agency")
    public ApiResult queryUnitAgency(@RequestBody @Valid UnitAgencyQuery unitAgencyQuery) throws IOException {

        TotalResultDTO<List<UnitIdDTO>> totalResult = unitService.getUnitAgencyByQuery(unitAgencyQuery, UnitIdDTO.class, indexName);

        return ApiResult.builder()
                .status(ApiStatus.SUCCESS_CODE)
                .data(totalResult.getData())
                .total(totalResult.getTotal())
                .build();
    }

    @PostMapping("/test/query-unit-agency")
    public ApiResult testQueryUnitAgency(@RequestBody @Valid UnitAgencyQuery unitAgencyQuery) throws IOException {
        TotalResultDTO<List<UnitAgencyDTO>> totalResult = unitService.getUnitAgencyByQuery(unitAgencyQuery, UnitAgencyDTO.class, indexName);
        return ApiResult.builder()
                .status(ApiStatus.SUCCESS_CODE)
                .data(totalResult.getData())
                .total(totalResult.getTotal())
                .build();
    }


    @SkipMethod
    @Override
    public boolean isLoadData() {
        return loadDataStatusService.isLoaded();
    }
}