package com.trafficaudit.holiday.service;

import com.trafficaudit.holiday.HolidayConstants;
import com.trafficaudit.holiday.entity.HolidayVehicleAdjustment;
import com.trafficaudit.holiday.entity.HolidayVehicleFlow;
import com.trafficaudit.holiday.mapper.HolidayVehicleAdjustmentMapper;
import com.trafficaudit.holiday.mapper.HolidayVehicleFlowMapper;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

class HolidayVehicleAdjustmentServiceTest {

    @Test
    void listAddsOriginalNationalProvincialValueAndLeavesMissingSourceBlank() throws Exception {
        HolidayVehicleAdjustment adjusted = adjustment("2025-10-04", "337.5009");
        HolidayVehicleAdjustment missingSource = adjustment("2025-10-05", "330.0000");

        HolidayVehicleAdjustmentMapper adjustmentMapper = mock(HolidayVehicleAdjustmentMapper.class);
        HolidayVehicleFlowMapper vehicleFlowMapper = mock(HolidayVehicleFlowMapper.class);
        when(adjustmentMapper.selectList(any())).thenReturn(Arrays.asList(adjusted, missingSource));
        when(vehicleFlowMapper.selectList(any())).thenReturn(Collections.singletonList(
                vehicleFlow("2025-10-04", HolidayConstants.ROAD_NATIONAL_PROVINCIAL, "350.0000")));

        HolidayVehicleAdjustmentService service = new HolidayVehicleAdjustmentService();
        inject(service, "adjustmentMapper", adjustmentMapper);
        inject(service, "vehicleFlowMapper", vehicleFlowMapper);

        List<HolidayVehicleAdjustment> rows = service.list(2025);

        assertEquals(0, new BigDecimal("350.0000").compareTo(rows.get(0).getOriginalValue()));
        assertNull(rows.get(1).getOriginalValue());
    }

    @Test
    void findOriginalValueReturnsMatchedValueAndNullWhenMissing() throws Exception {
        HolidayVehicleFlowMapper vehicleFlowMapper = mock(HolidayVehicleFlowMapper.class);
        when(vehicleFlowMapper.selectOne(any()))
                .thenReturn(vehicleFlow("2025-10-04", HolidayConstants.ROAD_NATIONAL_PROVINCIAL, "337.9501"))
                .thenReturn(null);

        HolidayVehicleAdjustmentService service = new HolidayVehicleAdjustmentService();
        inject(service, "vehicleFlowMapper", vehicleFlowMapper);

        assertEquals(0, new BigDecimal("337.9501")
                .compareTo(service.findOriginalValue(2025, LocalDate.of(2025, 10, 4))));
        assertNull(service.findOriginalValue(2025, LocalDate.of(2025, 10, 5)));
        assertThrows(IllegalArgumentException.class,
                () -> service.findOriginalValue(2025, LocalDate.of(2024, 10, 4)));
    }
    private static HolidayVehicleAdjustment adjustment(String date, String adjustedValue) {
        HolidayVehicleAdjustment row = new HolidayVehicleAdjustment();
        row.setYear(LocalDate.parse(date).getYear());
        row.setFlowDate(LocalDate.parse(date));
        row.setAdjustedValue(new BigDecimal(adjustedValue));
        return row;
    }

    private static HolidayVehicleFlow vehicleFlow(String date, String roadCategory, String value) {
        HolidayVehicleFlow row = new HolidayVehicleFlow();
        row.setYear(LocalDate.parse(date).getYear());
        row.setFlowDate(LocalDate.parse(date));
        row.setRoadCategory(roadCategory);
        row.setVehicleCount(new BigDecimal(value));
        return row;
    }

    private static void inject(Object target, String fieldName, Object value) throws Exception {
        Field field = target.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(target, value);
    }
}