import SwiftUI
import SwiftData

struct RemindersListView: View {
    @Environment(\.modelContext) private var ctx
    @Query(sort: \MetricReminder.updatedAt, order: .reverse)
    private var reminders: [MetricReminder]

    @State private var editingId: String?

    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 12) {
                header
                if reminders.isEmpty {
                    emptyState
                } else {
                    ForEach(reminders) { r in
                        ReminderRow(
                            reminder: r,
                            isEditing: editingId == r.metricId,
                            onTapEdit: { toggleEdit(r.metricId) },
                            onChange: { Task { await sync(r) } },
                            onDelete: { delete(r) }
                        )
                    }
                }
            }
            .padding(.horizontal, 16)
            .padding(.top, 12)
            .padding(.bottom, 32)
        }
        .background(Tj.Palette.sand.ignoresSafeArea())
        .navigationTitle("记录提醒")
        .navigationBarTitleDisplayMode(.inline)
    }

    private var header: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text("\(enabledCount) / \(reminders.count) 项启用")
                .font(.system(size: 12))
                .foregroundStyle(Tj.Palette.text3)
            Text("提醒在录入「指标记录 · 长期监测」时开启")
                .font(.system(size: 12))
                .foregroundStyle(Tj.Palette.text3)
        }
        .frame(maxWidth: .infinity, alignment: .leading)
    }

    private var emptyState: some View {
        VStack(spacing: 12) {
            Spacer(minLength: 40)
            TjPlaceholder(label: "还没有记录提醒\n去「+ 指标记录」录入时打开")
                .frame(width: 240, height: 140)
            Spacer()
        }
        .frame(maxWidth: .infinity)
    }

    private var enabledCount: Int { reminders.filter(\.enabled).count }

    private func toggleEdit(_ id: String) {
        editingId = (editingId == id) ? nil : id
    }

    private func sync(_ r: MetricReminder) async {
        r.updatedAt = .now
        try? ctx.save()
        await ReminderService.sync(r)
    }

    private func delete(_ r: MetricReminder) {
        ReminderService.cancel(metricId: r.metricId)
        ctx.delete(r)
        try? ctx.save()
    }
}

private struct ReminderRow: View {
    @Bindable var reminder: MetricReminder
    let isEditing: Bool
    let onTapEdit: () -> Void
    let onChange: () -> Void
    let onDelete: () -> Void

    @State private var pickedTime: Date = .now
    @State private var hydrated = false

    var body: some View {
        VStack(spacing: 12) {
            headerRow
            if isEditing {
                editingPanel
            }
        }
        .padding(14)
        .background(
            RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
                .fill(Tj.Palette.paper)
        )
        .overlay(
            RoundedRectangle(cornerRadius: Tj.Radius.md, style: .continuous)
                .strokeBorder(Tj.Palette.lineSoft, lineWidth: 1)
        )
    }

    private var headerRow: some View {
        HStack(spacing: 12) {
            ZStack {
                Circle()
                    .fill(reminder.enabled ? Tj.Palette.amber.opacity(0.25) : Tj.Palette.sand2)
                Image(systemName: "bell.fill")
                    .font(.system(size: 16))
                    .foregroundStyle(reminder.enabled ? Tj.Palette.ink : Tj.Palette.text3)
            }
            .frame(width: 36, height: 36)

            VStack(alignment: .leading, spacing: 2) {
                Text(reminder.displayName)
                    .font(.system(size: 15, weight: .semibold))
                    .foregroundStyle(Tj.Palette.text)
                Text("\(reminder.timeLabel) · \(reminder.frequencyLabel)")
                    .font(.system(size: 12))
                    .foregroundStyle(Tj.Palette.text3)
            }

            Spacer()

            Toggle("", isOn: $reminder.enabled)
                .labelsHidden()
                .tint(Tj.Palette.ink)
                .onChange(of: reminder.enabled) { _, _ in onChange() }

            Button {
                onTapEdit()
            } label: {
                Image(systemName: isEditing ? "chevron.up" : "chevron.down")
                    .font(.system(size: 12, weight: .semibold))
                    .foregroundStyle(Tj.Palette.text3)
                    .frame(width: 28, height: 28)
            }
            .buttonStyle(.plain)
        }
    }

    private var editingPanel: some View {
        VStack(alignment: .leading, spacing: 12) {
            HStack {
                Text("时间").font(.system(size: 13)).foregroundStyle(Tj.Palette.text2)
                Spacer()
                DatePicker("", selection: $pickedTime, displayedComponents: .hourAndMinute)
                    .datePickerStyle(.compact)
                    .labelsHidden()
                    .onChange(of: pickedTime) { _, new in
                        let cal = Calendar.current
                        reminder.hour = cal.component(.hour, from: new)
                        reminder.minute = cal.component(.minute, from: new)
                        onChange()
                    }
            }
            weekdayRow
            HStack {
                Spacer()
                Button(role: .destructive) {
                    onDelete()
                } label: {
                    Label("删除提醒", systemImage: "trash")
                        .font(.system(size: 12, weight: .semibold))
                        .foregroundStyle(Tj.Palette.brick)
                }
                .buttonStyle(.plain)
            }
        }
        .onAppear {
            if !hydrated {
                pickedTime = Calendar.current.date(
                    bySettingHour: reminder.hour, minute: reminder.minute, second: 0, of: .now
                ) ?? .now
                hydrated = true
            }
        }
    }

    private var weekdayRow: some View {
        let names = ["一", "二", "三", "四", "五", "六", "日"]
        let weekdayValues = [2, 3, 4, 5, 6, 7, 1]
        return HStack(spacing: 6) {
            ForEach(Array(weekdayValues.enumerated()), id: \.offset) { idx, w in
                Button {
                    var s = Set(reminder.weekdays)
                    if s.contains(w) { s.remove(w) } else { s.insert(w) }
                    reminder.weekdays = s.sorted()
                    onChange()
                } label: {
                    Text(names[idx])
                        .font(.system(size: 13,
                                      weight: reminder.weekdays.contains(w) ? .semibold : .regular))
                        .foregroundStyle(reminder.weekdays.contains(w) ? Tj.Palette.paper : Tj.Palette.text)
                        .frame(maxWidth: .infinity, minHeight: 30)
                        .background(
                            RoundedRectangle(cornerRadius: 8, style: .continuous)
                                .fill(reminder.weekdays.contains(w) ? Tj.Palette.ink : Tj.Palette.paper)
                        )
                        .overlay(
                            RoundedRectangle(cornerRadius: 8, style: .continuous)
                                .strokeBorder(Tj.Palette.line,
                                              lineWidth: reminder.weekdays.contains(w) ? 0 : 1)
                        )
                }
                .buttonStyle(.plain)
            }
        }
    }
}

#Preview {
    NavigationStack {
        RemindersListView()
    }
    .modelContainer(for: [MetricReminder.self], inMemory: true)
}