/**
 * 
 */
package de.etecture.ga.api;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Optional;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.Assert;

import de.etecture.ga.dto.Termin;
import de.etecture.ga.dto.TerminRequest;
import de.etecture.ga.dto.mapper.AppointmentTerminMapper;
import de.etecture.ga.model.Appointment;
import de.etecture.ga.service.AppointmentService;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;

/**
 * 
 */
@AllArgsConstructor
@Controller
@Slf4j
public class GarageApiController implements WerkstattApi {

	private final AppointmentService appointmentService;

	@Override
	public ResponseEntity<Termin> getTermin(@NotNull String werkstattId, @NotNull String terminId) {

		Assert.isTrue(NumberUtils.isParsable(werkstattId), "werkstattId ungültig");
		Assert.isTrue(NumberUtils.isParsable(terminId), "terminId ungültig");

		Optional<Appointment> appointment = appointmentService.getAppointment(Long.parseLong(terminId),
				Long.parseLong(werkstattId));

		return ResponseEntity.of(appointment.map(AppointmentTerminMapper::toTermin));
	}

	@Override
	public ResponseEntity<List<Termin>> getTermine(@NotNull String werkstattId, @Valid String von, @Valid String bis,
			@Valid String leistungsId) {

		Assert.isTrue(NumberUtils.isParsable(werkstattId), "werkstattId ungültig");

		long garageId = Long.parseLong(werkstattId);
		Optional<Long> serviceId = NumberUtils.isParsable(leistungsId) ? Optional.of(Long.parseLong(leistungsId))
				: Optional.empty();
		Optional<Date> appointmentsFrom = Optional.ofNullable(parseDate(von));
		Optional<Date> appointmentsTill = Optional.ofNullable(parseDate(bis));

		log.info("Filter appointments by garage {}, serviceId {}, from {}, till {}", garageId, serviceId,
				appointmentsFrom, appointmentsTill);

		return ResponseEntity
				.ok(appointmentService.getAppointments(garageId, serviceId, appointmentsFrom, appointmentsTill).stream()
						.map(AppointmentTerminMapper::toTermin).toList());
	}

	@Override
	public ResponseEntity<List<Termin>> getTerminvorschlaege(String werkstattId, @NotNull @Valid String leistungsId,
			@Valid String von, @Valid String bis) {
		// TODO Auto-generated method stub
		return WerkstattApi.super.getTerminvorschlaege(werkstattId, leistungsId, von, bis);
	}

	@Override
	public ResponseEntity<Termin> postTermin(String werkstattId, @Valid TerminRequest termin) {

		// input validation
		Assert.isTrue(NumberUtils.isParsable(werkstattId), "werkstattId ungültig");
		Assert.isTrue(NumberUtils.isParsable(termin.getLeistungsId()), "leistungsId ungültig");
		Assert.notNull(parseDate(termin.getVon()), "von ungültig");
		Assert.notNull(parseDate(termin.getBis()), "bis ungültig");
		
		long garageId = Long.parseLong(werkstattId);
		long serviceId = Long.parseLong(termin.getLeistungsId());
		Date appointmentFrom = parseDate(termin.getVon());
		Date appointmentTill = parseDate(termin.getBis());
		
		// create appointment if possible
		Optional<Appointment> appointment = appointmentService.createAppointment(garageId, serviceId,
				appointmentFrom, appointmentTill);

		return appointment.map(a -> ResponseEntity.ok(AppointmentTerminMapper.toTermin(a)))
				.orElse(ResponseEntity.status(HttpStatus.CONFLICT).build());
	}

	private Date parseDate(String dateTimeString) {

		if (StringUtils.isNotBlank(dateTimeString)) {
			try {
				SimpleDateFormat format = new SimpleDateFormat("dd.MM.yyyy HH:mm");

				return format.parse(dateTimeString);
			} catch (ParseException e) {
				log.error("Invalid data to parse", e);
			}
		}

		return null;
	}
}