package etunicorn.controller;

import etunicorn.RestrictedTo;
import etunicorn.entity.Personne;
import etunicorn.entity.Role;
import etunicorn.generated.model.UpdatePersonneByIdRequest;
import etunicorn.generated.model.UpdatePersonneRequest;
import etunicorn.generated.model.UpdateVirerRequest;
import etunicorn.repository.PersonneRepository;
import etunicorn.repository.RoleRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * etunicorn-server
 * Copyright © 2017 Le Club Info Polytech Lille
 * Tous droits réservés
 */

@RestController
public class PersonneController extends BaseController implements etunicorn.generated.PersonneController {
    @Autowired
    private PersonneRepository personneRepository;

    @Autowired
    private RoleRepository roleRepository;

    @Override
    @RestrictedTo("PERSONNE_LIST")
    public ResponseEntity<?> getPersonne() {
        return new ResponseEntity<List>((List) this.personneRepository.findAll(), HttpStatus.OK);
    }

    private ResponseEntity<?> mergePersonne(Personne personne, UpdatePersonneRequest updatePersonneRequest) {
        if (updatePersonneRequest.getNaissance() != null) {
            SimpleDateFormat format = new SimpleDateFormat("y-M-d");
            try {
                personne.setNaissance(format.parse(updatePersonneRequest.getNaissance()));
            } catch (ParseException e) {
                return generateError(HttpStatus.BAD_REQUEST, e, "La date n'est pas au format " + format.toString());
            }
        }
        if (updatePersonneRequest.getCarte() != null) {
            personne.setCarte(updatePersonneRequest.getCarte());
        }
        if (updatePersonneRequest.getLogin() != null) {
            personne.setLogin(updatePersonneRequest.getLogin());
        }
        if (updatePersonneRequest.getRole() != null) {
            if (updatePersonneRequest.getRole() instanceof LinkedHashMap) {
                LinkedHashMap<String, String> roleMap = (LinkedHashMap<String, String>) updatePersonneRequest.getRole();
                Role role = roleRepository.findByNom(roleMap.get("nom"));
                if (role == null) {
                    return generateError(HttpStatus.NOT_FOUND, "Rôle inconnu");
                }
                if (personne.getRole() != role) {
                    if (hasPermission("PERSONNE_ROLE")) {
                        personne.setRole(role);
                    } else {
                        return generateError(HttpStatus.FORBIDDEN, "Vous ne pouvez pas changer le rôle");
                    }
                }
            } else {
                return generateError(HttpStatus.BAD_REQUEST, "Le rôle est un objet");
            }
        }

        if (personne.getCarte() == null && personne.getLogin() == null) {
            return generateError(HttpStatus.BAD_REQUEST, "Le login ou la carte doivent être au moins renseignés.");
        }
        if (personne.getRole() == null) {
            personne.setRole(roleRepository.findByNom("etudiant"));
        }

        try {
            this.personneRepository.save(personne);
        } catch (DataIntegrityViolationException e) {
            return generateError(HttpStatus.CONFLICT, "Un utilisateur avec la même carte ou le même login existe déjà");
        }
        return new ResponseEntity<Object>(personne, HttpStatus.CREATED);
    }

    @Override
    @RestrictedTo("PERSONNE_ADD")
    public ResponseEntity<?> updatePersonne(@Valid @RequestBody UpdatePersonneRequest updatePersonneRequest) {
        Personne personne = new Personne();
        return mergePersonne(personne, updatePersonneRequest);
    }

    @Override
    @RestrictedTo("PERSONNE_GET")
    public ResponseEntity<?> getPersonneById(@PathVariable BigDecimal idPersonne) {
        Personne personne = personneRepository.findById(idPersonne.intValue());
        if (personne == null) {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<Object>(personne, HttpStatus.OK);
    }

    @Override
    @RestrictedTo("PERSONNE_EDIT")
    public ResponseEntity<?> updatePersonneById(@PathVariable BigDecimal idPersonne, @Valid @RequestBody UpdatePersonneByIdRequest updatePersonneByIdRequest) {
        Personne personne = personneRepository.findById(idPersonne.intValue());
        if (personne == null) {
            return generateError(HttpStatus.NOT_FOUND, "Personne introuvable");
        }
        UpdatePersonneRequest updatePersonneRequest = new UpdatePersonneRequest();
        updatePersonneRequest.setCarte(updatePersonneByIdRequest.getCarte());
        updatePersonneRequest.setNaissance(updatePersonneByIdRequest.getNaissance());
        updatePersonneRequest.setLogin(updatePersonneByIdRequest.getLogin());
        updatePersonneRequest.setRole(updatePersonneByIdRequest.getRole());
        return mergePersonne(personne, updatePersonneRequest);
    }

    @Override
    @RestrictedTo("PERSONNE_REMOVE")
    public ResponseEntity<?> deletePersonneById(@PathVariable BigDecimal idPersonne) {
        Personne personne = personneRepository.findById(idPersonne.intValue());

        if (personne == null) {
            return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
        }
        personneRepository.delete(personne);
        return new ResponseEntity<Object>(personne, HttpStatus.NO_CONTENT);
    }

    @Override
    public ResponseEntity<?> updateVirer(@PathVariable BigDecimal idPersonne, @Valid @RequestBody UpdateVirerRequest updateVirerRequest) {
        return null;
    }
}