package inc.sdt.controlcentermanagement.application;

import com.fasterxml.jackson.core.type.TypeReference;
import inc.sdt.controlcentermanagement.domain.*;
import inc.sdt.controlcentermanagement.infrastructure.resttemplate.RestTemplateRequestHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.util.UriComponentsBuilder;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * @author sunae.jang (sa.jang@sdt.inc)
 */
@Service
class DefaultTubeService implements TubeService {
    private final SlotRepositoryDelegate slotRepositoryDelegate;
    private final RestTemplateRequestHandler restTemplateHandler;
    private final String deployerEndpoint;
    private final Logger log;

    public DefaultTubeService(SlotRepositoryDelegate slotRepositoryDelegate, RestTemplateRequestHandler restTemplateHandler, @Value("${deployer.endpoint}") String deployerEndpoint) {
        this.slotRepositoryDelegate = slotRepositoryDelegate;
        this.restTemplateHandler = restTemplateHandler;
        this.deployerEndpoint = deployerEndpoint;
        this.log = LoggerFactory.getLogger(DefaultTubeService.class);
    }

    @Override
    public List<Slot> get(String chamberNumber) {
        log.info("[get] chamberNumber: {}", chamberNumber);
        return slotRepositoryDelegate.get(chamberNumber);
    }

    @Override
    public void controlByTubeCode(String authorization, Slot request) {
        log.info("[controlByTubeCode] request: {}", request);
        Map<String, String> tubeMap = new LinkedHashMap<>();
        for (Tube tube : request.getTube()) {
            Map<String, Integer> tubeOffsetMap = this.tubeOffset();
            String offsetKey = request.getSlotNumber().substring(request.getSlotNumber().length() - 1);
            int tubeOffset = tubeOffsetMap.getOrDefault(offsetKey, 1);
            int tubeKey = Integer.parseInt(tube.getCode()) + tubeOffset;
            tubeMap.put(String.valueOf(tubeKey), String.valueOf(request.getCommand().ordinal()));
        }

        DeployRequest deployRequest = DeployRequest.builder()
                .assetCode(request.getAssetCode())
                .deviceType("nodeq")
                .appName(request.getSlotNumber())
                .commandType(CommandType.JSON)
                .parameters(tubeMap)
                .build();

        this.invokeDeployer(request.getAssetCode(), authorization, deployRequest);
    }

    @Override
    public void controlAll(String authorization, List<Slot> slots, Command command) {
        log.info("[controlAll] chamberNumber: {}, command: {}", slots.get(0).getChamberNumber(), command);

        Map<String, Map<String, Map<String, String>>> resultMap = new LinkedHashMap<>();
        for (Slot slot : slots) {
            String assetCode = slot.getAssetCode();
            String slotNumber = slot.getSlotNumber();
            List<Tube> tubes = slot.getTube();

            Map<String, Map<String, String>> assetMap = resultMap.computeIfAbsent(assetCode, k -> new HashMap<>());
            Map<String, String> slotMap = assetMap.computeIfAbsent(slotNumber, k -> new HashMap<>());

            for (Tube tube : tubes) {
                Map<String, Integer> tubeOffsetMap = this.tubeOffset();
                String offsetKey = slotNumber.substring(slotNumber.length() - 1);
                int tubeOffset = tubeOffsetMap.getOrDefault(offsetKey, 1);
                int offsetResult = Integer.parseInt(tube.getCode()) + tubeOffset;
                slotMap.put(String.valueOf(offsetResult), String.valueOf(command.ordinal()));
            }
        }

        resultMap.forEach((assetCode, slot) -> slot.forEach((slotNumber, tube) -> {
            DeployRequest deployRequest = DeployRequest.builder()
                    .assetCode(assetCode)
                    .deviceType("nodeq")
                    .appName(slotNumber)
                    .commandType(CommandType.JSON)
                    .parameters(tube)
                    .build();

            this.invokeDeployer(assetCode, authorization, deployRequest);
        }));
    }

    private Map<String, Integer> tubeOffset() {
        int offset = 0;
        Map<String, Integer> tubeOffsetMap = new HashMap<>();
        for (int i = 1; i <= 8; i++) {
            tubeOffsetMap.put(String.valueOf(i), offset);
            offset += 16;
            if (i == 4) offset = 0;
        }
        return tubeOffsetMap;
    }

    private void invokeDeployer(String assetCode, String authorization, DeployRequest deployRequest) {
        String url = UriComponentsBuilder.fromUriString(deployerEndpoint)
                .path(String.format("/assets/%s/apps", assetCode))
                .build()
                .toUriString();
        restTemplateHandler.httpPostRequestWithAuth(url, authorization, deployRequest, new TypeReference<>() {
        });
    }
}