package jnpf.elnController;

import jnpf.elnService.ElnRecordFillTicketService;
import jnpf.elnService.ElnRecordFillDataService;
import jnpf.elnService.ElnRecordRepeatService;
import jnpf.elnService.ElnRecordSourceSyncService;
import jnpf.elnEntity.runtime.ElnRecordForms;
import jnpf.elnEntity.runtime.ElnRecordVos;
import jnpf.util.NoDataSourceBind;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;

@RestController
@RequestMapping({"/onlyoffice/recordFill", "/onlyoffice/templateFill"})
public class ElnRecordFillController {

    private static final String TICKET_PREFIX = "Ticket ";
    private final ElnRecordFillTicketService ticketService;
    private final ElnRecordFillDataService recordFillDataService;
    private final ElnRecordRepeatService recordRepeatService;
    private final ElnRecordSourceSyncService recordSourceSyncService;

    ElnRecordFillController(ElnRecordFillTicketService ticketService) {
        this(ticketService, ticket -> Collections.emptyMap(), null, null);
    }

    public ElnRecordFillController(ElnRecordFillTicketService ticketService,
                                  ElnRecordFillDataService recordFillDataService) {
        this(ticketService, recordFillDataService, null, null);
    }

    public ElnRecordFillController(ElnRecordFillTicketService ticketService,
                                  ElnRecordFillDataService recordFillDataService,
                                  ElnRecordRepeatService recordRepeatService) {
        this(ticketService, recordFillDataService, recordRepeatService, null);
    }

    @Autowired
    public ElnRecordFillController(ElnRecordFillTicketService ticketService,
                                  ElnRecordFillDataService recordFillDataService,
                                  ElnRecordRepeatService recordRepeatService,
                                  ElnRecordSourceSyncService recordSourceSyncService) {
        this.ticketService = ticketService;
        this.recordFillDataService = recordFillDataService;
        this.recordRepeatService = recordRepeatService;
        this.recordSourceSyncService = recordSourceSyncService;
    }

    @PostMapping("/sourceSync/preview")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.SourceSyncPreview> previewSourceSync(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization) {
        try {
            return ResponseEntity.ok(recordSourceSyncService.preview(parseTicket(authorization)));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }

    @PostMapping("/sourceSync")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.SourceSynchronized> synchronizeSource(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.SourceSync command) {
        try {
            return ResponseEntity.ok(
                    recordSourceSyncService.synchronize(parseTicket(authorization), command));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }

    @GetMapping("/data")
    @NoDataSourceBind
    public ResponseEntity<Map<String, Object>> data(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            ElnRecordVos.SourceSynchronized pending = recordSourceSyncService == null
                    ? null : recordSourceSyncService.pending(ticket);
            Map<String, Object> data = new LinkedHashMap<>(recordFillDataService.data(ticket));
            if (recordSourceSyncService != null) {
                data.put("pendingSourceSync", pending);
            }
            return ResponseEntity.ok(data);
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(Collections.emptyMap());
        }
    }

    @PostMapping("/repeatRows")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.RepeatRow> appendRepeatRow(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.RepeatAppend form) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            return ResponseEntity.ok(recordRepeatService.append(ticket, form));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }

    @PostMapping("/repeatRows/delete")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.RepeatRow> deleteRepeatRow(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.RepeatDelete form) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            return ResponseEntity.ok(recordRepeatService.requestDelete(ticket, form));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }

    @PostMapping("/repeatRows/restore")
    @NoDataSourceBind
    public ResponseEntity<ElnRecordVos.RepeatRow> restoreRepeatRow(
            @RequestHeader(value = HttpHeaders.AUTHORIZATION, required = false) String authorization,
            @RequestBody(required = false) ElnRecordForms.RepeatRestore form) {
        try {
            ElnRecordFillTicketService.FillTicketContext ticket = parseTicket(authorization);
            return ResponseEntity.ok(recordRepeatService.restoreDelete(ticket, form));
        } catch (ElnRecordFillTicketService.InvalidFillTicketException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build();
        }
    }

    private ElnRecordFillTicketService.FillTicketContext parseTicket(String authorization) {
        if (authorization == null || !authorization.startsWith(TICKET_PREFIX)
                || authorization.length() == TICKET_PREFIX.length()) {
            throw new ElnRecordFillTicketService.InvalidFillTicketException();
        }
        return ticketService.parse(authorization.substring(TICKET_PREFIX.length()).trim());
    }
}