package io.gmss.fiscad.implementations.infocad.metier;

import io.gmss.fiscad.entities.infocad.metier.Tpe;
import io.gmss.fiscad.exceptions.BadRequestException;
import io.gmss.fiscad.exceptions.NotFoundException;
import io.gmss.fiscad.interfaces.infocad.metier.TpeService;
import io.gmss.fiscad.repositories.infocad.metier.EnqueteRepository;
import io.gmss.fiscad.repositories.infocad.metier.TpeRepository;
import io.gmss.fiscad.service.StringService;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

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

@Service
public class TpeServiceImpl implements TpeService {

    private final TpeRepository tpeRepository;
    private final EnqueteRepository enqueteRepository;

    public TpeServiceImpl(TpeRepository tpeRepository, EnqueteRepository enqueteRepository) {
        this.tpeRepository = tpeRepository;
        this.enqueteRepository = enqueteRepository;
    }

    @Override
    public Tpe createTpe(Tpe tpe) throws BadRequestException {
        String codeEquipe;
        do {
            codeEquipe = StringService.getCodeEquipe();
        } while (tpeRepository.existsDistinctByCodeEquipe(codeEquipe));

        tpe.setCodeEquipe(codeEquipe);

        if (tpe.getId() != null) {
            throw new BadRequestException("Impossible de créer un nouveau tpe ayant un id non null.");
        }

        if (tpeRepository.existsDistinctByIdentifier(tpe.getIdentifier())) {
            return tpeRepository.findDistinctByIdentifier(tpe.getIdentifier()).get();
        } else {
            return tpeRepository.save(tpe);
        }
    }

    @Override
    public Tpe updateTpe(Long id, Tpe tpe) throws NotFoundException {
        if (tpe.getId() == null) {
            throw new BadRequestException("Impossible de mettre à jour un nouveau tpe ayant un id null.");
        }
        if (!tpeRepository.existsById(tpe.getId())) {
            throw new NotFoundException("Impossible de trouver le tpe spécifié dans notre base de données.");
        }
        return tpeRepository.save(tpe);
    }

    @Override
    public Tpe majTpe(Long id, Tpe tpe) throws NotFoundException {
        if (tpe.getId() == null) {
            throw new BadRequestException("Impossible de mettre à jour un nouveau tpe ayant un id null.");
        }
        Optional<Tpe> optionalTpe=tpeRepository.findById(tpe.getId());
        if (optionalTpe.isEmpty()) {
            tpeRepository.insertTpeManuellement(tpe.getId(),
                    tpe.getNumeroEquipement(),
                    tpe.getIdentifier(),
                    tpe.getModel(),
                    tpe.getCodeEquipe()
                    );
        }else{
            tpeRepository.save(optionalTpe.get());
        }
        return tpe ;
    }

    @Override
    public void deleteTpe(Long id) throws NotFoundException {
        Optional<Tpe> tpeOptional = tpeRepository.findById(id);
        if (tpeOptional.isPresent()) {
            tpeRepository.deleteById(tpeOptional.get().getId());
        } else {
            throw new NotFoundException("Impossible de trouver le tpe spécifié dans notre base de données.");
        }
    }

    @Override
    public Page<Tpe> getTpeList(Pageable pageable) {
        return tpeRepository.findAll(pageable);
    }

    @Override
    public List<Tpe> getTpeList() {
        return tpeRepository.findAll();
    }

    @Override
    public Optional<Tpe> getTpeById(Long id) {
        if (tpeRepository.existsById(id)) {
            return tpeRepository.findById(id);
        } else {
            throw new NotFoundException("Impossible de trouver le tpe spécifié dans la base de données.");
        }

    }

    @Override
    public Optional<Tpe> getTepByIdentifier(String identifier) {
        if (tpeRepository.existsDistinctByIdentifier(identifier)) {
            return tpeRepository.findDistinctByIdentifier(identifier);
        } else {
            throw new NotFoundException("Impossible de trouver le tpe lié à cette clé dans la base de données.");
        }
    }

    @Override
    public List<Tpe> getTpeListByModel(String model) {
        if (model != null) {
            return tpeRepository.findAllByModel(model);
        } else {
            throw new BadRequestException("Vous devez spécifier le model du tpe.");
        }
    }

    @Override
    public List<Tpe> getTpeListByUserId(Long userId) {
        return tpeRepository.getTpeByUserId(userId);
    }
    @Override
    public Tpe reCreateExistTpe(Tpe tpe) throws BadRequestException {

        tpeRepository.save(tpe);
        return tpe;
    }
}
