package etunicorn.controller;

  import com.fasterxml.jackson.annotation.JsonProperty;

  import etunicorn.entity.Permission;
  import etunicorn.entity.Session;
  import etunicorn.exception.EntityRequestMismatchException;
  import etunicorn.exception.NotEnoughDataException;
  import etunicorn.exception.ObjectNotFoundException;
  import etunicorn.repository.PermissionRepository;
  import etunicorn.service.SessionService;

  import net.minidev.json.JSONObject;

  import org.springframework.beans.factory.annotation.Autowired;

  import org.springframework.data.repository.Repository;

  import org.springframework.http.HttpStatus;
  import org.springframework.http.ResponseEntity;

  import org.springframework.web.bind.annotation.RestController;
  

  import javax.persistence.Entity;

  import javax.servlet.http.HttpServletRequest;

  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;

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

  
  /**
   * etunicorn-server
   * Copyright © 2017 Le Club Info Polytech Lille
   * Tous droits réservés
   */
  @RestController
  public class BaseController {
  

      // Utilités pour merger un request dans une entity
      @Autowired
      Map<String, Repository> repositories;

      // Permettent la vérification de permissions dans les méthodes de controlleur
      @Autowired
      private HttpServletRequest request;
      @Autowired
      private SessionService sessionService;
      @Autowired
      private PermissionRepository permissionRepository;
  
      protected boolean hasPermission(Permission permission) {
          Session session = sessionService.getSession(request);
          if (session == null || permission == null) {
              return false;
          }
          return session.hasPermission(permission);
      }
  
      protected boolean hasPermission(String nomPermission) {
          Permission permission = permissionRepository.findByNom(nomPermission);
          return hasPermission(permission);
      }

  
      // Utilités pour générer des erreurs
      ResponseEntity generateError(HttpStatus status, String message) {
          JSONObject json = new JSONObject();
          json.put("status", status.value());
          json.put("message", message);
          return new ResponseEntity(json, status);
      }
  
      ResponseEntity generateError(HttpStatus status) {
          return generateError(status, String.format("Erreur de type %d", status.value()));
      }
  
      ResponseEntity generateError(HttpStatus status, Exception exception, String message) {
          JSONObject json = new JSONObject();
          json.put("status", status.value());
          json.put("message", message);
          json.put("errorMessage", exception.getLocalizedMessage());
          json.put("stacktrace", exception.getStackTrace().toString());
          return new ResponseEntity(json, status);
      }
  
      ResponseEntity generateError(Exception exception) {
          return generateError(HttpStatus.INTERNAL_SERVER_ERROR, exception, exception.getLocalizedMessage());
      }
  

      protected Object getEntityFromObject(String className, LinkedHashMap object) throws NotEnoughDataException {
          Object repository = repositories.get(className + "Repository");
          for (Method findMethod : repository.getClass().getMethods()) {
              String findMethodName = findMethod.getName();
              if (findMethodName.startsWith("findBy")) {
                  String key = Character.toLowerCase(findMethodName.charAt(6)) + findMethodName.substring(7);
                  if (object.containsKey(key)) {
                      try {
                          Object data = object.get(key);
                          return findMethod.invoke(repository, data);
                      } catch (IllegalAccessException e) {
                          continue;
                      } catch (InvocationTargetException e) {
                          continue;
                      }
                  } else {
                      continue;
                  }
              }
          }
          throw new NotEnoughDataException();
      }
  
      protected void mergeRequestInEntity(Object request, Object entity) throws EntityRequestMismatchException, NotEnoughDataException, ObjectNotFoundException {

          for (Method getMethode : request.getClass().getMethods()) {
              String getMethodName = getMethode.getName();
              JsonProperty annotation = getMethode.getAnnotation(JsonProperty.class);
              if (getMethodName.startsWith("get") && annotation != null) {

                  String fieldName = annotation.value();

                  String setMethodName = "s" + getMethodName.substring(1);
                  Method setMethode;
                  Class fieldClass;
                  try {
                      fieldClass = entity.getClass().getMethod(getMethodName).getReturnType();
                      setMethode = entity.getClass().getMethod(setMethodName, fieldClass);
                  } catch (NoSuchMethodException e) {
                      throw new EntityRequestMismatchException();
                  }
                  try {
                      if (getMethode.invoke(request) != null) {
                          Object data = getMethode.invoke(request);
                          if (data.getClass() != fieldClass) {

                              if (fieldClass.getAnnotation(Entity.class) != null) {
                                  data = getEntityFromObject(fieldName, (LinkedHashMap) data);
                                  if (data == null) {
                                      throw new ObjectNotFoundException();
                                  }
                              } else {
                                  Constructor constructor = fieldClass.getConstructor(data.getClass());
                                  if (constructor != null) {
                                      data = constructor.newInstance(data);
                                  }

                              }
                          }
                          setMethode.invoke(entity, data);
                      }
                  } catch (IllegalAccessException e) {
                      throw new EntityRequestMismatchException();
                  } catch (InvocationTargetException e) {
                      throw new EntityRequestMismatchException();
                  } catch (NoSuchMethodException e) {
                      throw new EntityRequestMismatchException();
                  } catch (InstantiationException e) {
                      throw new EntityRequestMismatchException();
                  }
              }
  
          }
      }

  }