package com.release11.klaus.controller;


import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.service.KlausService;
import com.release11.klaus.utilis.BusinessKey;
import com.release11.klaus.utilis.TrackingClient;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;

@Controller("/")
@Slf4j
@AllArgsConstructor
public class KlausController {

    private final KlausService klausService;

    @DeleteMapping(value = "klaus/v1/delete/{clientUUID}/{mockedResponseId}")
    public ResponseEntity<String> deleteMockedResponse(@PathVariable UUID clientUUID,
                                                       @PathVariable int mockedResponseId){
        TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "deleteMockedResponse",
                BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
                BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseId)));
        klausService.deleteMockedResponse(clientUUID, mockedResponseId);
        return new ResponseEntity<>("message has been deleted", HttpStatus.OK);
    }

    @GetMapping(value = "klaus/v1/getAll/{clientUUID}")
    public ResponseEntity<String> getAllMockedResponses(@PathVariable UUID clientUUID){
        TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getAllMockedResponse",
                BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
                BusinessKey.MESSAGE_ID, "all"));
        List<MockedMessageDto> mockedMessages = klausService.getAllMockedResponses(clientUUID);
        return new ResponseEntity<>(mockedMessages.toString(), HttpStatus.OK);
    }

    @RequestMapping(value = "klaus/v1/get/{clientUUID}/{mockedResponseId}")
    public ResponseEntity getMockedResponse(@PathVariable UUID clientUUID,
                                            @PathVariable int mockedResponseId){
        TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse",
                BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
                BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseId)));
        MockedMessageDto mockedMessageDto = klausService.getMockedResponse(clientUUID, mockedResponseId);
        HttpHeaders httpHeaders = new HttpHeaders();
        if (mockedMessageDto.getHttpHeaders() != null) mockedMessageDto.getHttpHeaders().forEach(httpHeaders::set);
        return new ResponseEntity<>(mockedMessageDto.getMessageBody(), httpHeaders,
                Objects.requireNonNull(HttpStatus.valueOf(mockedMessageDto.getHttpStatus())));
    }

    @PostMapping(value = "klaus/v1/set/{clientUUID}/{mockedResponseId}")
    public ResponseEntity<String> setMockedResponse(@PathVariable UUID clientUUID,
                                                    @PathVariable int mockedResponseId,
                                                    @RequestParam(required = false) Integer httpStatus,
                                                    RequestEntity<String> requestEntity){
        TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "setMockedResponse",
                BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
                BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseId)));
        if (httpStatus == null) httpStatus = 200;

        MockedMessageDto mockedMessageDto = new MockedMessageDto(clientUUID, mockedResponseId,
                requestEntity.getHeaders().getContentType().toString(), requestEntity.getBody(),
                requestEntity.getHeaders().toSingleValueMap(), httpStatus);
        return klausService.setMockedResponse(mockedMessageDto);
    }

}