package ru.ulstu.paper.controller;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.Errors;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import ru.ulstu.conference.service.ConferenceService;
import ru.ulstu.deadline.model.Deadline;
import ru.ulstu.paper.model.AutoCompleteData;
import ru.ulstu.paper.model.Paper;
import ru.ulstu.paper.model.PaperDto;
import ru.ulstu.paper.model.PaperListDto;
import ru.ulstu.paper.model.ReferenceDto;
import ru.ulstu.paper.service.LatexService;
import ru.ulstu.paper.service.PaperService;
import ru.ulstu.user.model.User;
import springfox.documentation.annotations.ApiIgnore;

import javax.validation.Valid;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.stream.Collectors;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.springframework.util.StringUtils.isEmpty;


@Controller()
@RequestMapping(value = "/papers")
@ApiIgnore
public class PaperController {
    private final PaperService paperService;
    private final ConferenceService conferenceService;
    private final LatexService latexService;

    public PaperController(PaperService paperService,
                           ConferenceService conferenceService,
                           LatexService latexService) {
        this.paperService = paperService;
        this.conferenceService = conferenceService;
        this.latexService = latexService;
    }

    @GetMapping("/papers")
    public void getPapers(ModelMap modelMap) {
        modelMap.put("filteredPapers", new PaperListDto(paperService.findAllDto(), null, null));
    }

    @PostMapping("/papers")
    public void listPapers(@Valid PaperListDto paperListDto, ModelMap modelMap) {
        if (paperListDto.getPaperDeleteId() != null) {
            if (conferenceService.isAttachedToConference(paperListDto.getPaperDeleteId())) {
                modelMap.put("flashMessage", "Статью нельзя удалить, она прикреплена к конференции");
            } else {
                paperService.delete(paperListDto.getPaperDeleteId());
            }
        }
        modelMap.put("filteredPapers", new PaperListDto(paperService.filter(paperListDto),
                paperListDto.getFilterAuthorId(),
                paperListDto.getYear()));
    }

    @GetMapping("/dashboard")
    public void getDashboard(ModelMap modelMap) {
        modelMap.put("papers", paperService.findAllActiveDto());
    }

    @GetMapping("/paper")
    public void getPapers(ModelMap modelMap, @RequestParam(value = "id") Integer id) {
        if (id != null && id > 0) {
            modelMap.put("paperDto", paperService.findOneDto(id));
        } else {
            modelMap.put("paperDto", new PaperDto());
        }
    }

    @PostMapping(value = "/paper", params = "save")
    public String save(@Valid PaperDto paperDto, Errors errors) throws IOException {
        filterEmptyDeadlines(paperDto);
        if (paperDto.getDeadlines().isEmpty()) {
            errors.rejectValue("deadlines", "errorCode", "Не может быть пустым");
        }
        if (errors.hasErrors()) {
            return "/papers/paper";
        }
        paperService.save(paperDto);
        return "redirect:/papers/papers";
    }

    @PostMapping(value = "/paper", params = "addDeadline")
    public String addDeadline(@Valid PaperDto paperDto, Errors errors) {
        filterEmptyDeadlines(paperDto);
        if (errors.hasErrors()) {
            return "/papers/paper";
        }
        paperDto.getDeadlines().add(new Deadline());
        return "/papers/paper";
    }

    @PostMapping(value = "/paper", params = "addReference")
    public String addReference(@Valid PaperDto paperDto, Errors errors) {
        if (errors.hasErrors()) {
            return "/papers/paper";
        }
        paperDto.getReferences().add(new ReferenceDto());
        return "/papers/paper";
    }

    @ModelAttribute("allStatuses")
    public List<Paper.PaperStatus> getPaperStatuses() {
        return paperService.getPaperStatuses();
    }

    @ModelAttribute("allTypes")
    public List<Paper.PaperType> getPaperTypes() {
        return paperService.getPaperTypes();
    }

    @ModelAttribute("allAuthors")
    public List<User> getAllAuthors() {
        return paperService.getPaperAuthors();
    }

    @ModelAttribute("allYears")
    public List<Integer> getAllYears() {
        List<Integer> years = new ArrayList<>();
        for (int i = Calendar.getInstance().get(Calendar.YEAR); i > 2010; i--) {
            years.add(i);
        }
        return years;
    }

    @ModelAttribute("allFormatStandards")
    public List<ReferenceDto.FormatStandard> getFormatStandards() {
        return paperService.getFormatStandards();
    }

    @ModelAttribute("allReferenceTypes")
    public List<ReferenceDto.ReferenceType> getReferenceTypes() {
        return paperService.getReferenceTypes();
    }

    @PostMapping("/generatePdf")
    public ResponseEntity<byte[]> getPdfFile(PaperDto paper) throws IOException, InterruptedException {
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Disposition", "attachment; filename='" +
                URLEncoder.encode(paper.getTitle() + ".pdf", UTF_8.toString()) + "'");
        return new ResponseEntity<>(latexService.generatePdfFromLatexFile(paper), headers, HttpStatus.OK);
    }

    @PostMapping("/getFormattedReferences")
    public ResponseEntity<String> getFormattedReferences(PaperDto paperDto) {
        return new ResponseEntity<>(paperService.getFormattedReferences(paperDto), new HttpHeaders(), HttpStatus.OK);
    }

    @ModelAttribute("autocompleteData")
    public AutoCompleteData getAutocompleteData() {
        return paperService.getAutoCompleteData();
    }

    private void filterEmptyDeadlines(PaperDto paperDto) {
        paperDto.setDeadlines(paperDto.getDeadlines().stream()
                .filter(dto -> dto.getDate() != null || !isEmpty(dto.getDescription()))
                .collect(Collectors.toList()));
    }
}