import SwiftUI
import SwiftData
#if canImport(UIKit)
import UIKit
#endif
import Data
import HabitTray
import Interaction
import Timeline

public struct DayView: View {
    @Environment(HabitDragCoordinator.self) private var dragCoordinator
    @Environment(\.modelContext) private var modelContext
    @State private var selectedDate: Date = Calendar.current.startOfDay(for: .now)
    @State private var hoveredSlot: Int?
    @State private var timelineFrame: CGRect = .zero
    @State private var currentScrollOffset: CGFloat = 0
    @State private var lastHapticSlot: Int?

    private let referenceDate: Date = Calendar.current.startOfDay(for: .now)
    private let pageRange: Int = 365
    private let initialScrollSlot: Int = min(TimelineLayout.totalSlots - 1, TimelineLayout.slotIndex(for: .now) + 3)

    public init() {}

    public var body: some View {
        VStack(spacing: 0) {
            DateHeaderView(selectedDate: $selectedDate)

            TabView(selection: pageIndexBinding) {
                ForEach(-pageRange...pageRange, id: \.self) { offset in
                    DayTimelineView(
                        date: date(for: offset),
                        initialScrollSlot: initialScrollSlot,
                        hoveredSlot: $hoveredSlot,
                        scrollOffset: $currentScrollOffset
                    )
                        .tag(offset)
                }
            }
            .tabViewStyle(.page(indexDisplayMode: .never))
            .onGeometryChange(for: CGRect.self) { proxy in
                proxy.frame(in: .global)
            } action: { frame in
                timelineFrame = frame
            }
        }
        .onChange(of: dragCoordinator.dragLocation) { _, location in
            guard dragCoordinator.isActive else { return }
            hoveredSlot = slot(for: location)
        }
        .onChange(of: dragCoordinator.pendingDrop) { _, pendingDrop in
            guard pendingDrop else { return }
            handleDrop()
        }
        .onChange(of: hoveredSlot) { _, newSlot in
            guard dragCoordinator.isActive, let slot = newSlot, slot != lastHapticSlot else { return }
            hapticSnap()
            lastHapticSlot = slot
        }
        .sheet(isPresented: .constant(true)) {
            HabitTrayView()
        }
    }

    private var pageIndexBinding: Binding<Int> {
        Binding(
            get: {
                Calendar.current.dateComponents([.day], from: referenceDate, to: selectedDate).day ?? 0
            },
            set: { offset in
                selectedDate = date(for: offset)
            }
        )
    }

    private func date(for offset: Int) -> Date {
        Calendar.current.date(byAdding: .day, value: offset, to: referenceDate) ?? referenceDate
    }

    private func slot(for point: CGPoint) -> Int? {
        guard timelineFrame.contains(point) else { return nil }
        let localY = point.y - timelineFrame.minY
        let contentY = localY + currentScrollOffset
        let slot = Int(contentY / TimelineLayout.slotHeight)
        guard (0..<TimelineLayout.totalSlots).contains(slot) else { return nil }
        return slot
    }

    private func handleDrop() {
        defer {
            dragCoordinator.end()
            hoveredSlot = nil
            lastHapticSlot = nil
        }

        guard let habit = dragCoordinator.draggedHabit, let slot = hoveredSlot else { return }

        let minuteOfDay = slot * TimelineLayout.slotMinutes
        guard let startTime = Calendar.current.date(
            bySettingHour: minuteOfDay / 60,
            minute: minuteOfDay % 60,
            second: 0,
            of: selectedDate
        ) else {
            return
        }

        let instance = HabitInstance(
            habit: habit,
            startTime: startTime,
            duration: habit.defaultDuration
        )
        modelContext.insert(instance)
        hapticDrop()
    }
}

private func hapticSnap() {
#if canImport(UIKit)
    UIImpactFeedbackGenerator(style: .light).impactOccurred()
#endif
}

private func hapticDrop() {
#if canImport(UIKit)
    UIImpactFeedbackGenerator(style: .medium).impactOccurred()
#endif
}

private struct DateHeaderView: View {
    @Binding var selectedDate: Date
    @State private var showingDatePicker = false

    private static let formatter: DateFormatter = {
        let f = DateFormatter()
        f.dateFormat = "EEEE, MMM d"
        return f
    }()

    var body: some View {
        HStack {
            Button {
                selectedDate = Calendar.current.date(byAdding: .day, value: -1, to: selectedDate) ?? selectedDate
            } label: {
                Image(systemName: "chevron.left")
                    .fontWeight(.semibold)
            }

            Spacer()

            Button {
                showingDatePicker = true
            } label: {
                Text(Self.formatter.string(from: selectedDate))
                    .fontWeight(.semibold)
                    .foregroundStyle(.primary)
            }
            .sheet(isPresented: $showingDatePicker) {
                DatePickerSheet(selectedDate: $selectedDate, isPresented: $showingDatePicker)
            }

            Spacer()

            Button {
                selectedDate = Calendar.current.date(byAdding: .day, value: 1, to: selectedDate) ?? selectedDate
            } label: {
                Image(systemName: "chevron.right")
                    .fontWeight(.semibold)
            }
        }
        .padding(.horizontal)
        .padding(.vertical, 12)
        .background(.bar)
    }
}

private struct DatePickerSheet: View {
    @Binding var selectedDate: Date
    @Binding var isPresented: Bool

    var body: some View {
        NavigationStack {
            DatePicker(
                "Select Date",
                selection: $selectedDate,
                displayedComponents: .date
            )
            .datePickerStyle(.graphical)
            .padding()
            .navigationTitle("Go to Date")
            .navigationBarTitleDisplayMode(.inline)
            .toolbar {
                ToolbarItem(placement: .confirmationAction) {
                    Button("Done") { isPresented = false }
                }
            }
        }
        .presentationDetents([.medium])
    }
}