package com.release11.klaus.controller;


import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.model.MockedMessageDtoTest;
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.time.LocalDateTime;
import java.util.*;


/**
 * A class responds to generated message uri's requests.
 * It deletes or fetches the requested message
 */
@Controller("/")
@Slf4j
//@Profile({"DEV", "default"})
@AllArgsConstructor
public class KlausController {

    private final KlausService klausService;
    MockedMessageDto msg = MockedMessageDto.builder()
            .clientUUID(UUID.randomUUID())
            .httpStatus(200)
            .mediaType("text/xml")
            .messageBody("Hello world")
            .mockedResponseId(1)
            .httpHeaders(new HashMap<>())
            .build();


    @ResponseBody
    @GetMapping(value = "klaus/v1/get/test/msgtest")
    public MockedMessageDtoTest getTestMessageTest(){
        MockedMessageDtoTest msg = new MockedMessageDtoTest();
        return msg;
    }

    @ResponseBody
    @GetMapping(value = "klaus/v1/get/test/msg")
    public MockedMessageDto getTestMessage(){
        Map<String, String> headers = new HashMap<>();
        headers.put("Keep-Alive", "timeout=60");
        headers.put("Connection", "keep-alive");
        headers.put("Date", LocalDateTime.now().toString());
        MockedMessageDto msg = MockedMessageDto.builder()
                .clientUUID(UUID.randomUUID())
                .httpStatus(200)
                .mediaType("text/xml")
                .messageBody("Hello world")
                .mockedResponseId(1)
                .httpHeaders(headers)
                .build();
        return msg;
    }


    @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)));
        List<MockedMessageDto> mockedMessages = klausService.getAllMockedResponses(clientUUID);
        return new ResponseEntity<>(mockedMessages.toString(), HttpStatus.OK);
    }

    @RequestMapping(value = "klaus/v1/get/{clientUUID}/{mockedResponseId}")
    public ResponseEntity getMockedResponse(RequestEntity<String> requestEntity,
                                            @PathVariable UUID clientUUID,
                                            @PathVariable int mockedResponseId) {
        TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse - request",
                BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
                BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseId)));
        log.info(requestEntity.toString().replaceAll("\"", "\\\\\"").substring(1));
        TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse - response",
                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())));
    }

}