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.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) {

          SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

          if (updatePersonneRequest.getNaissance() != null) {

              try {
                  personne.setNaissance(format.parse(updatePersonneRequest.getNaissance()));
              } catch (ParseException e) {
                  e.printStackTrace();
              }

          }

          if (updatePersonneRequest.getCarte() != null) {
              personne.setCarte(updatePersonneRequest.getCarte());

          }

          if (updatePersonneRequest.getLogin() != null) {
              personne.setLogin(updatePersonneRequest.getLogin());

          }

          if (personne.getCarte() == null && personne.getLogin() == null) {
              return generateError(HttpStatus.BAD_REQUEST, "La date ou la carte doivent être au moins renseignés.");
          }
          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");

              }
          }
          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.intValueExact());
          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.intValueExact());
          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.intValueExact());
          if (personne == null) {
              return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
          }
          personneRepository.delete(personne);
          return new ResponseEntity<Object>(personne, HttpStatus.NO_CONTENT);

      }

  }