package org.berzerkula.builddb.controllers;


import jakarta.validation.Valid;
import org.berzerkula.builddb.BuilddbConstants;
import org.berzerkula.builddb.models.Pkg;
import org.berzerkula.builddb.models.PkgDto;
import org.berzerkula.builddb.repositories.PkgRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@Controller
@RequestMapping("/pkgs")
public class PkgController {

    private static final Logger logger = LoggerFactory.getLogger(PkgController.class);

    private final PkgRepository repo;

    public PkgController(PkgRepository repo) {
        this.repo = repo;
    }

    @GetMapping({"", "/", "/index"})
    public String showPkgList(Model model,
                              @RequestParam(defaultValue = "sequence,asc") String[] sort,
                              @RequestParam(defaultValue = "") String repotable) {
        try {
            String sortField = sort[0];
            String sortDirection = sort[1];

            Sort.Direction direction = sortDirection.equals("desc") ? Sort.Direction.DESC : Sort.Direction.ASC;
            Sort.Order order = new Sort.Order(direction, sortField);

            List<Pkg> pkgs = repo.findAll(Sort.by(order));

            model.addAttribute("pkgs", pkgs);
            model.addAttribute("sortField", sortField);
            model.addAttribute("sortDirection", sortDirection);
            model.addAttribute("reverseSortDirection", sortDirection.equals("asc") ? "desc" : "asc");

        } catch (Exception e) {
            logger.error(e.getMessage());
        }

        return "pkgs/index";
    }

    @GetMapping("/add")
    public String showAddPkgForm(Model model) {
        PkgDto pkgDto = new PkgDto();
        model.addAttribute("pkgDto", pkgDto);
        return "pkgs/add";
    }

    @PostMapping("/add")
    public String addPkg(
            @Valid
            @ModelAttribute
            PkgDto pkgDto, BindingResult result ) {

        if (result.hasErrors()) {
            return "pkgs/add";
        }

        try {

            Pkg pkg = new Pkg();
            pkg.setSequence(pkgDto.getSequence());
            pkg.setName(pkgDto.getName());
            pkg.setVersion(pkgDto.getVersion());
            pkg.setConfigure(pkgDto.getConfigure());
            pkg.setBuild(pkgDto.getBuild());
            pkg.setInstall(pkgDto.getInstall());
            pkg.setSetup(pkgDto.getSetup());
            pkg.setNotes(pkgDto.getNotes());
            pkg.setUrl(pkgDto.getUrl());

            repo.save(pkg);

        } catch (Exception e) {
            logger.error(e.getMessage());
        }

        return "redirect:/pkgs";
    }

    @GetMapping("/edit")
    public String showEditPkgForm(Model model, @RequestParam int id) {

        try {

            Optional<Pkg> pkgOptional = repo.findById(id);
            if (pkgOptional.isPresent()) {
                Pkg pkg = pkgOptional.get();
                model.addAttribute("pkg", pkg);

                PkgDto pkgDto = new PkgDto();
                pkgDto.setSequence(pkg.getSequence());
                pkgDto.setName(pkg.getName());
                pkgDto.setVersion(pkg.getVersion());
                pkgDto.setConfigure(pkg.getConfigure());
                pkgDto.setBuild(pkg.getBuild());
                pkgDto.setInstall(pkg.getInstall());
                pkgDto.setSetup(pkg.getSetup());
                pkgDto.setNotes(pkg.getNotes());
                pkgDto.setUrl(pkg.getUrl());

                model.addAttribute("pkgDto", pkgDto);
            }

        } catch(Exception ex) {
            logger.error(BuilddbConstants.MSG_EXCEPTION, ex.getMessage());
        }

        return "pkgs/edit";
    }

    @PostMapping("/edit")
    public String editPkg(
            Model model,
            @RequestParam int id,
            @Valid
            @ModelAttribute PkgDto pkgDto, BindingResult result ) {

        try {
            Optional<Pkg> pkgOptional = repo.findById(id);
            if (pkgOptional.isPresent()) {
                Pkg pkg = pkgOptional.get();
                model.addAttribute("pkg", pkg);

                if (result.hasErrors()) {
                    return "pkgs/edit";
                }

                pkg.setSequence(pkgDto.getSequence());
                pkg.setName(pkgDto.getName());
                pkg.setVersion(pkgDto.getVersion());
                pkg.setConfigure(pkgDto.getConfigure());
                pkg.setBuild(pkgDto.getBuild());
                pkg.setInstall(pkgDto.getInstall());
                pkg.setSetup(pkgDto.getSetup());
                pkg.setNotes(pkgDto.getNotes());
                pkg.setUrl(pkgDto.getUrl());

                repo.save(pkg);
            }

        } catch(Exception ex) {
            logger.error(BuilddbConstants.MSG_EXCEPTION, ex.getMessage());
        }
        return "redirect:/pkgs/#" + id;

    }

    @GetMapping("/delete")
    public String deletePkg(@RequestParam int id) {

        try {
            Optional<Pkg> pkgOptional = repo.findById(id);
            if (pkgOptional.isPresent()) {
                Pkg pkg = pkgOptional.get();
                repo.delete(pkg);
            }

        } catch (Exception ex) {
            logger.error(BuilddbConstants.MSG_EXCEPTION, ex.getMessage());
        }

        return "redirect:/pkgs/";
    }
}