package com.healthcare.ohctech.service.impl;

import com.healthcare.ohctech.dto.PatientDailyBodyMeasurementDto;
import com.healthcare.ohctech.dto.PatientDailyExerciseDto;
import com.healthcare.ohctech.entity.ExerciseMaster;
import com.healthcare.ohctech.entity.Patient;
import com.healthcare.ohctech.entity.PatientDailyBodyMeasurement;
import com.healthcare.ohctech.entity.PatientDailyExercise;
import com.healthcare.ohctech.repository.ExerciseMasterRepo;
import com.healthcare.ohctech.repository.PatientDailyExerciseRepo;
import com.healthcare.ohctech.repository.PatientRepo;
import com.healthcare.ohctech.service.PatientDailyExerciseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class PatientDailyExerciseServiceImpl implements PatientDailyExerciseService {

    @Autowired
    private PatientDailyExerciseRepo patientDailyExerciseRepo;
    @Autowired
    private ExerciseMasterRepo exerciseMasterRepo;
    @Autowired
    private PatientRepo patientRepo;

    @Override
    public List<PatientDailyExerciseDto> getPatientExercisesByEmpId(Long empId) {
        List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAllByPatientId(empId);

        Map<LocalDate, List<PatientDailyExercise>> exercisesByDate = exercises.stream()
                .collect(Collectors.groupingBy(PatientDailyExercise::getDate));

        return exercisesByDate.entrySet().stream()
                .sorted(Map.Entry.<LocalDate, List<PatientDailyExercise>>comparingByKey().reversed())
                .map(entry -> {
                    LocalDate date = entry.getKey();
                    List<PatientDailyExercise> dailyExercises = entry.getValue();

                    Map<Long, PatientDailyExerciseDto.ExerciseValue> exerciseValues = dailyExercises.stream()
                            .collect(Collectors.toMap(
                                    e -> e.getExerciseMaster().getId(),
                                    e -> new PatientDailyExerciseDto.ExerciseValue(
                                            e.getValue(),
                                            e.getRemark(),
                                            e.getExerciseMaster().getUnitMaster().getId()
                                    )
                            ));

                    return new PatientDailyExerciseDto(
                            dailyExercises.get(0).getId(),
                            dailyExercises.get(0).getPatient().getId(),
                            date,
                            dailyExercises.get(0).getModifiedBy(),
                            dailyExercises.get(0).getLastModified(),
                            exerciseValues
                    );
                })
                .collect(Collectors.toList());
    }

    @Override
    public PatientDailyExerciseDto getPatientExerciseByEmpIdAndDate(Long empId, LocalDate date) {
        List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAllByPatientIdAndDate(empId, date);

        if (exercises.isEmpty()) {
            return null;
        }

        Map<Long, PatientDailyExerciseDto.ExerciseValue> exerciseValues = exercises.stream()
                .collect(Collectors.toMap(
                        e -> e.getExerciseMaster().getId(),
                        e -> new PatientDailyExerciseDto.ExerciseValue(
                                e.getValue(),
                                e.getRemark(),
                                e.getExerciseMaster().getUnitMaster().getId()
                        )
                ));

        PatientDailyExercise firstExercise = exercises.get(0);

        return new PatientDailyExerciseDto(
                firstExercise.getId(),
                empId,
                firstExercise.getDate(),
                firstExercise.getModifiedBy(),
                firstExercise.getLastModified(),
                exerciseValues
        );
    }

    @Override
    public List<PatientDailyExerciseDto> getAllPatientExercises() {
        List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAll();

        Map<Long, PatientDailyExerciseDto> dtoMap = exercises.stream()
                .collect(Collectors.groupingBy(
                        exercise -> exercise.getPatient().getId(),
                        Collectors.collectingAndThen(
                                Collectors.toList(),
                                exerciseList -> {
                                    Map<Long, PatientDailyExerciseDto.ExerciseValue> exerciseValues = exerciseList.stream()
                                            .collect(Collectors.toMap(
                                                    exercise -> exercise.getExerciseMaster().getId(),
                                                    exercise -> new PatientDailyExerciseDto.ExerciseValue(exercise.getValue(), exercise.getRemark(), exercise.getExerciseMaster().getUnitMaster().getId())
                                            ));
                                    return new PatientDailyExerciseDto(
                                            exerciseList.get(0).getId(),
                                            exerciseList.get(0).getPatient().getId(),
                                            exerciseList.get(0).getDate(),
                                            exerciseList.get(0).getModifiedBy(),
                                            exerciseList.get(0).getLastModified(),
                                            exerciseValues
                                    );
                                }
                        )
                ));
        return new ArrayList<>(dtoMap.values());
    }

    @Override
    public void addPatientExercise(PatientDailyExerciseDto exerciseDto, Long userId) {
        List<PatientDailyExercise> exercises = convertToEntity(exerciseDto, userId);
        patientDailyExerciseRepo.saveAll(exercises);
    }

    @Override
    public void updatePatientExercise(Long empId, PatientDailyExerciseDto exerciseDto, Long userId) {
        List<PatientDailyExercise> existingExercises = patientDailyExerciseRepo.findAllByPatientIdAndDate(empId, exerciseDto.date());

        for (Map.Entry<Long, PatientDailyExerciseDto.ExerciseValue> entry : exerciseDto.exerciseValues().entrySet()) {
            Long exerciseId = entry.getKey();
            PatientDailyExerciseDto.ExerciseValue exerciseValue = entry.getValue();

            PatientDailyExercise exercise = existingExercises.stream()
                    .filter(e -> e.getExerciseMaster().getId().equals(exerciseId))
                    .findFirst()
                    .orElse(new PatientDailyExercise());

            ExerciseMaster exerciseMaster = exerciseMasterRepo.findById(exerciseId)
                    .orElseThrow(() -> new RuntimeException("Exercise not found for ID: " + exerciseId));

            exercise.setPatient(patientRepo.findById(empId)
                    .orElseThrow(() -> new RuntimeException("Patient not found for ID: " + empId)));
            exercise.setExerciseMaster(exerciseMaster);
            exercise.setValue(exerciseValue.value());
            exercise.setRemark(exerciseValue.remark());
            exercise.setDate(exerciseDto.date());
            exercise.setModifiedBy(userId);

            patientDailyExerciseRepo.save(exercise);
        }
    }

    @Override
    public void deletePatientExercise(Long empId, LocalDate date) {
        List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAllByPatientIdAndDate(empId, date);

        if (exercises.isEmpty()) {
            throw new RuntimeException("No Patient Exercises found for EmpId: " + empId + " and Date: " + date);
        }
        patientDailyExerciseRepo.deleteAll(exercises);
    }


    private List<PatientDailyExercise> convertToEntity(PatientDailyExerciseDto exerciseDto, Long userId) {
        Patient patient = patientRepo.findById(exerciseDto.empId())
                .orElseThrow(() -> new RuntimeException("Patient not found for ID: " + exerciseDto.empId()));

        return exerciseDto.exerciseValues().entrySet().stream().map(entry -> {
            Long exerciseId = entry.getKey();
            PatientDailyExerciseDto.ExerciseValue exerciseValue = entry.getValue();

            ExerciseMaster exerciseMaster = exerciseMasterRepo.findById(exerciseId)
                    .orElseThrow(() -> new RuntimeException("Exercise not found for ID: " + exerciseId));

            PatientDailyExercise exercise = new PatientDailyExercise();
            exercise.setPatient(patient);
            exercise.setExerciseMaster(exerciseMaster);
            exercise.setValue(exerciseValue.value());
            exercise.setRemark(exerciseValue.remark());
            exercise.setDate(exerciseDto.date());
            exercise.setModifiedBy(userId);

            return exercise;
        }).collect(Collectors.toList());
    }
}