import { Configuration } from '../configuration/CalendarConfig';
import { IColumnBounds } from './ColumnDetectionUtils';
import { DateService } from './DateService';
import { TimeFormatter } from './TimeFormatter';

/**
 * PositionUtils - Positioning utilities with dependency injection
 * Focuses on pixel/position calculations while delegating date operations
 *
 * Note: Uses DateService with date-fns for all date/time operations
 */
export class PositionUtils {
    private dateService: DateService;
    private config: Configuration;

    constructor(dateService: DateService, config: Configuration) {
        this.dateService = dateService;
        this.config = config;
    }

    /**
     * Convert minutes to pixels
     */
    public minutesToPixels(minutes: number): number {
        const gridSettings = this.config.getGridSettings();
        const pixelsPerHour = gridSettings.hourHeight;
        return (minutes / 60) * pixelsPerHour;
    }

    /**
     * Convert pixels to minutes
     */
    public pixelsToMinutes(pixels: number): number {
        const gridSettings = this.config.getGridSettings();
        const pixelsPerHour = gridSettings.hourHeight;
        return (pixels / pixelsPerHour) * 60;
    }

    /**
     * Convert time (HH:MM) to pixels from day start using DateService
     */
    public timeToPixels(timeString: string): number {
        const totalMinutes = this.dateService.timeToMinutes(timeString);
        const gridSettings = this.config.getGridSettings();
        const dayStartMinutes = gridSettings.dayStartHour * 60;
        const minutesFromDayStart = totalMinutes - dayStartMinutes;

        return this.minutesToPixels(minutesFromDayStart);
    }

    /**
     * Convert Date object to pixels from day start using DateService
     */
    public dateToPixels(date: Date): number {
        const totalMinutes = this.dateService.getMinutesSinceMidnight(date);
        const gridSettings = this.config.getGridSettings();
        const dayStartMinutes = gridSettings.dayStartHour * 60;
        const minutesFromDayStart = totalMinutes - dayStartMinutes;

        return this.minutesToPixels(minutesFromDayStart);
    }

    /**
     * Convert pixels to time using DateService
     */
    public pixelsToTime(pixels: number): string {
        const minutes = this.pixelsToMinutes(pixels);
        const gridSettings = this.config.getGridSettings();
        const dayStartMinutes = gridSettings.dayStartHour * 60;
        const totalMinutes = dayStartMinutes + minutes;

        return this.dateService.minutesToTime(totalMinutes);
    }

    /**
     * Beregn event position og størrelse
     */
    public calculateEventPosition(startTime: string | Date, endTime: string | Date): {
        top: number;
        height: number;
        duration: number;
    } {
        let startPixels: number;
        let endPixels: number;

        if (typeof startTime === 'string') {
            startPixels = this.timeToPixels(startTime);
        } else {
            startPixels = this.dateToPixels(startTime);
        }

        if (typeof endTime === 'string') {
            endPixels = this.timeToPixels(endTime);
        } else {
            endPixels = this.dateToPixels(endTime);
        }

        const height = Math.max(endPixels - startPixels, this.getMinimumEventHeight());
        const duration = this.pixelsToMinutes(height);

        return {
            top: startPixels,
            height,
            duration
        };
    }

    /**
     * Snap position til grid interval
     */
    public snapToGrid(pixels: number): number {
        const gridSettings = this.config.getGridSettings();
        const snapInterval = gridSettings.snapInterval;
        const snapPixels = this.minutesToPixels(snapInterval);

        return Math.round(pixels / snapPixels) * snapPixels;
    }

    /**
     * Snap time to interval using DateService
     */
    public snapTimeToInterval(timeString: string): string {
        const totalMinutes = this.dateService.timeToMinutes(timeString);
        const gridSettings = this.config.getGridSettings();
        const snapInterval = gridSettings.snapInterval;

        const snappedMinutes = Math.round(totalMinutes / snapInterval) * snapInterval;
        return this.dateService.minutesToTime(snappedMinutes);
    }

    /**
     * Beregn kolonne position for overlappende events
     */
    public calculateColumnPosition(eventIndex: number, totalColumns: number, containerWidth: number): {
        left: number;
        width: number;
    } {
        const columnWidth = containerWidth / totalColumns;
        const left = eventIndex * columnWidth;

        // Lav lidt margin mellem kolonnerne
        const margin = 2;
        const adjustedWidth = columnWidth - margin;

        return {
            left: left + (margin / 2),
            width: Math.max(adjustedWidth, 50) // Minimum width
        };
    }

    /**
     * Check om to events overlapper i tid
     */
    public eventsOverlap(
        start1: string | Date,
        end1: string | Date,
        start2: string | Date,
        end2: string | Date
    ): boolean {
        const pos1 = this.calculateEventPosition(start1, end1);
        const pos2 = this.calculateEventPosition(start2, end2);

        const event1End = pos1.top + pos1.height;
        const event2End = pos2.top + pos2.height;

        return !(event1End <= pos2.top || event2End <= pos1.top);
    }

    /**
     * Beregn Y position fra mouse/touch koordinat
     */
    public getPositionFromCoordinate(clientY: number, column: IColumnBounds): number {

        const relativeY = clientY - column.boundingClientRect.top;

        // Snap til grid
        return this.snapToGrid(relativeY);
    }

    /**
     * Valider at tid er inden for arbejdstimer
     */
    public isWithinWorkHours(timeString: string): boolean {
        const [hours] = timeString.split(':').map(Number);
        const gridSettings = this.config.getGridSettings();
        return hours >= gridSettings.workStartHour && hours < gridSettings.workEndHour;
    }

    /**
     * Valider at tid er inden for dag grænser
     */
    public isWithinDayBounds(timeString: string): boolean {
        const [hours] = timeString.split(':').map(Number);
        const gridSettings = this.config.getGridSettings();
        return hours >= gridSettings.dayStartHour && hours < gridSettings.dayEndHour;
    }

    /**
     * Hent minimum event højde i pixels
     */
    public getMinimumEventHeight(): number {
        // Minimum 15 minutter
        return this.minutesToPixels(15);
    }

    /**
     * Hent maksimum event højde i pixels (hele dagen)
     */
    public getMaximumEventHeight(): number {
        const gridSettings = this.config.getGridSettings();
        const dayDurationHours = gridSettings.dayEndHour - gridSettings.dayStartHour;
        return dayDurationHours * gridSettings.hourHeight;
    }

    /**
     * Beregn total kalender højde
     */
    public getTotalCalendarHeight(): number {
        return this.getMaximumEventHeight();
    }

    /**
     * Convert ISO datetime to time string with UTC-to-local conversion
     */
    public isoToTimeString(isoString: string): string {
        const date = new Date(isoString);
        return TimeFormatter.formatTime(date);
    }

    /**
     * Convert time string to ISO datetime using DateService with timezone handling
     */
    public timeStringToIso(timeString: string, date: Date = new Date()): string {
        const totalMinutes = this.dateService.timeToMinutes(timeString);
        const newDate = this.dateService.createDateAtTime(date, totalMinutes);
        return this.dateService.toUTC(newDate);
    }

    /**
     * Calculate event duration using DateService
     */
    public calculateDuration(startTime: string | Date, endTime: string | Date): number {
        return this.dateService.getDurationMinutes(startTime, endTime);
    }

    /**
     * Format duration to readable text (Danish)
     */
    public formatDuration(minutes: number): string {
        if (minutes < 60) {
            return `${minutes} min`;
        }

        const hours = Math.floor(minutes / 60);
        const remainingMinutes = minutes % 60;

        if (remainingMinutes === 0) {
            return `${hours} time${hours !== 1 ? 'r' : ''}`;
        }

        return `${hours}t ${remainingMinutes}m`;
    }
}