// Views/Inspection/FormRenderer/FormFieldView.swift
// -------------------------------------------------
// Renders a single form field from the inspection template's form_schema.
// Supports all field types used by the JQC web app.

import SwiftUI
import PencilKit

// MARK: - FormFieldView

struct FormFieldView: View {

    let field: [String: Any]
    @Binding var value: String        // All values stored as strings; lists as JSON
    var onPhotoSelected: ((String) -> Void)? = nil  // callback with local file path

    private var fieldType: String { field["type"] as? String ?? "text" }
    private var label:     String { field["label"] as? String ?? "" }
    private var required:  Bool   { field["required"] as? Bool ?? false }
    private var placeholder: String { field["placeholder"] as? String ?? "" }

    var body: some View {
        VStack(alignment: .leading, spacing: 6) {

            // Field label (skip for section/label types which render themselves)
            if !["section", "label", "button_submit", "button_print", "button_email"]
                .contains(fieldType), !label.isEmpty {
                HStack(spacing: 4) {
                    Text(label)
                        .font(.subheadline)
                        .fontWeight(.medium)
                    if required {
                        Text("*")
                            .foregroundStyle(.red)
                            .font(.subheadline)
                    }
                }
            }

            // Field input
            fieldInput
        }
        .padding(.vertical, 2)
    }

    @ViewBuilder
    private var fieldInput: some View {
        switch fieldType {

        case "section":
            Text(label)
                .font(.headline)
                .foregroundStyle(.blue)
                .padding(.top, 8)

        case "label":
            let textContent = field["text_content"] as? String
                ?? field["text"] as? String
                ?? label
            Text(textContent)
                .font(.callout)
                .foregroundStyle(.secondary)

        case "text":
            TextField(placeholder.isEmpty ? label : placeholder, text: $value)
                .textFieldStyle(.roundedBorder)

        case "textarea":
            TextEditor(text: $value)
                .frame(minHeight: 80)
                .overlay(RoundedRectangle(cornerRadius: 6).stroke(Color(.systemGray4)))

        case "number":
            TextField(placeholder.isEmpty ? "0" : placeholder, text: $value)
                .textFieldStyle(.roundedBorder)
                .keyboardType(.decimalPad)

        case "email":
            TextField(placeholder.isEmpty ? "email@example.com" : placeholder, text: $value)
                .textFieldStyle(.roundedBorder)
                .keyboardType(.emailAddress)
                .textInputAutocapitalization(.never)

        case "date":
            DateFieldView(value: $value)

        case "checkbox":
            Toggle(label, isOn: Binding(
                get: { value == "true" },
                set: { value = $0 ? "true" : "false" }
            ))

        case "checkbox_group":
            CheckboxGroupView(field: field, value: $value)

        case "radio":
            RadioGroupView(field: field, value: $value)

        case "select":
            SelectFieldView(field: field, value: $value)

        case "rating":
            RatingFieldView(
                maxRating: field["max"] as? Int ?? 5,
                value: Binding(
                    get: { Int(value) ?? 0 },
                    set: { value = String($0) }
                )
            )

        case "pass_fail":
            PassFailFieldView(value: $value)

        case "signature":
            SignatureFieldView(value: $value)

        case "image":
            ImageFieldView(
                fieldId:         field["id"] as? String ?? UUID().uuidString,
                currentValue:    value,
                onPhotoSelected: onPhotoSelected
            )

        case "table":
            TableFieldView(field: field, value: $value)

        default:
            TextField(placeholder.isEmpty ? label : placeholder, text: $value)
                .textFieldStyle(.roundedBorder)
        }
    }
}

// MARK: - DateFieldView

struct DateFieldView: View {
    @Binding var value: String

    private var dateBinding: Binding<Date> {
        Binding(
            get: {
                let formatter = ISO8601DateFormatter()
                return formatter.date(from: value) ?? Date()
            },
            set: {
                let formatter = ISO8601DateFormatter()
                value = formatter.string(from: $0)
            }
        )
    }

    var body: some View {
        DatePicker("", selection: dateBinding, displayedComponents: .date)
            .labelsHidden()
    }
}

// MARK: - CheckboxGroupView

struct CheckboxGroupView: View {
    let field: [String: Any]
    @Binding var value: String  // JSON array of selected values

    private var options: [String] {
        field["options"] as? [String] ?? []
    }

    private var selectedValues: Set<String> {
        guard let data = value.data(using: .utf8),
              let array = try? JSONSerialization.jsonObject(with: data) as? [String]
        else { return [] }
        return Set(array)
    }

    private func toggle(_ option: String) {
        var current = selectedValues
        if current.contains(option) {
            current.remove(option)
        } else {
            current.insert(option)
        }
        let sorted = options.filter { current.contains($0) }
        if let data = try? JSONSerialization.data(withJSONObject: sorted),
           let str  = String(data: data, encoding: .utf8) {
            value = str
        }
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            ForEach(options, id: \.self) { option in
                Button {
                    toggle(option)
                } label: {
                    HStack {
                        Image(systemName: selectedValues.contains(option)
                              ? "checkmark.square.fill" : "square")
                            .foregroundStyle(selectedValues.contains(option) ? .blue : .secondary)
                        Text(option)
                            .foregroundStyle(.primary)
                    }
                }
                .buttonStyle(.plain)
            }
        }
    }
}

// MARK: - RadioGroupView

struct RadioGroupView: View {
    let field: [String: Any]
    @Binding var value: String

    private var options: [String] {
        field["options"] as? [String] ?? []
    }

    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            ForEach(options, id: \.self) { option in
                Button {
                    value = option
                } label: {
                    HStack {
                        Image(systemName: value == option
                              ? "largecircle.fill.circle" : "circle")
                            .foregroundStyle(value == option ? .blue : .secondary)
                        Text(option)
                            .foregroundStyle(.primary)
                    }
                }
                .buttonStyle(.plain)
            }
        }
    }
}

// MARK: - SelectFieldView

struct SelectFieldView: View {
    let field: [String: Any]
    @Binding var value: String

    private var options: [String] {
        field["options"] as? [String] ?? []
    }

    var body: some View {
        Picker("", selection: $value) {
            Text("Select…").tag("")
            ForEach(options, id: \.self) { option in
                Text(option).tag(option)
            }
        }
        .pickerStyle(.menu)
    }
}

// MARK: - RatingFieldView

struct RatingFieldView: View {
    let maxRating: Int
    @Binding var value: Int

    var body: some View {
        HStack(spacing: 8) {
            ForEach(1...maxRating, id: \.self) { star in
                Button {
                    value = (value == star) ? 0 : star  // tap same star to clear
                } label: {
                    Image(systemName: star <= value ? "star.fill" : "star")
                        .font(.title2)
                        .foregroundStyle(star <= value ? .yellow : .secondary)
                }
                .buttonStyle(.plain)
            }
            if value > 0 {
                Text("\(value)/\(maxRating)")
                    .font(.caption)
                    .foregroundStyle(.secondary)
                    .padding(.leading, 4)
            }
        }
    }
}

// MARK: - PassFailFieldView

struct PassFailFieldView: View {
    @Binding var value: String

    var body: some View {
        HStack(spacing: 12) {
            Button {
                value = value == "pass" ? "" : "pass"
            } label: {
                Label("Pass", systemImage: "checkmark.circle.fill")
                    .padding(.horizontal, 20)
                    .padding(.vertical, 10)
                    .background(value == "pass" ? Color.green : Color(.systemGray5))
                    .foregroundStyle(value == "pass" ? .white : .primary)
                    .clipShape(RoundedRectangle(cornerRadius: 8))
            }
            .buttonStyle(.plain)

            Button {
                value = value == "fail" ? "" : "fail"
            } label: {
                Label("Fail", systemImage: "xmark.circle.fill")
                    .padding(.horizontal, 20)
                    .padding(.vertical, 10)
                    .background(value == "fail" ? Color.red : Color(.systemGray5))
                    .foregroundStyle(value == "fail" ? .white : .primary)
                    .clipShape(RoundedRectangle(cornerRadius: 8))
            }
            .buttonStyle(.plain)
        }
    }
}

// MARK: - SignatureFieldView

struct SignatureFieldView: UIViewRepresentable {
    @Binding var value: String  // stored as base64 PNG data URL

    func makeUIView(context: Context) -> PKCanvasView {
        let canvas = PKCanvasView()
        canvas.drawingPolicy = .anyInput
        canvas.backgroundColor = UIColor.systemBackground
        canvas.layer.borderColor  = UIColor.systemGray4.cgColor
        canvas.layer.borderWidth  = 1
        canvas.layer.cornerRadius = 6
        canvas.delegate = context.coordinator
        return canvas
    }

    func updateUIView(_ canvas: PKCanvasView, context: Context) {}

    func makeCoordinator() -> Coordinator { Coordinator(value: $value) }

    class Coordinator: NSObject, PKCanvasViewDelegate {
        var value: Binding<String>
        init(value: Binding<String>) { self.value = value }

        func canvasViewDrawingDidChange(_ canvasView: PKCanvasView) {
            let image = canvasView.drawing.image(from: canvasView.bounds, scale: 1)
            if let data = image.pngData() {
                value.wrappedValue = "data:image/png;base64,\(data.base64EncodedString())"
            }
        }
    }
}

// MARK: - ImageFieldView

struct ImageFieldView: View {
    let fieldId: String
    let currentValue: String
    var onPhotoSelected: ((String) -> Void)?

    @State private var showPicker = false
    @State private var selectedImage: UIImage?

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            // Preview
            if let img = selectedImage {
                Image(uiImage: img)
                    .resizable()
                    .scaledToFit()
                    .frame(maxHeight: 200)
                    .clipShape(RoundedRectangle(cornerRadius: 8))
            } else if currentValue.hasPrefix("uploads/") {
                // Already uploaded in a previous session — show a placeholder
                HStack {
                    Image(systemName: "photo.fill")
                        .foregroundStyle(.secondary)
                    Text("Photo attached")
                        .font(.callout)
                        .foregroundStyle(.secondary)
                }
            }

            Button {
                showPicker = true
            } label: {
                Label(
                    selectedImage != nil || currentValue.hasPrefix("uploads/")
                        ? "Replace Photo" : "Attach Photo",
                    systemImage: "camera"
                )
            }
            .buttonStyle(.bordered)
        }
        .sheet(isPresented: $showPicker) {
            ImagePickerView(image: $selectedImage) { img in
                saveAndCallback(img)
            }
        }
    }

    private func saveAndCallback(_ img: UIImage) {
        guard let data = img.jpegData(compressionQuality: 0.8) else { return }
        let docsDir  = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
        let photosDir = docsDir.appendingPathComponent("JQC/Photos", isDirectory: true)
        try? FileManager.default.createDirectory(at: photosDir,
                                                  withIntermediateDirectories: true)
        let filename = "\(UUID().uuidString).jpg"
        let fileURL  = photosDir.appendingPathComponent(filename)
        try? data.write(to: fileURL)
        selectedImage = img
        onPhotoSelected?(fileURL.path)
    }
}

// MARK: - ImagePickerView

struct ImagePickerView: UIViewControllerRepresentable {
    @Binding var image: UIImage?
    var onSelected: (UIImage) -> Void

    func makeUIViewController(context: Context) -> UIImagePickerController {
        let picker = UIImagePickerController()
        picker.delegate    = context.coordinator
        picker.sourceType  = UIImagePickerController.isSourceTypeAvailable(.camera)
                             ? .camera : .photoLibrary
        return picker
    }

    func updateUIViewController(_ vc: UIImagePickerController, context: Context) {}
    func makeCoordinator() -> Coordinator { Coordinator(self) }

    class Coordinator: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
        let parent: ImagePickerView
        init(_ parent: ImagePickerView) { self.parent = parent }

        func imagePickerController(
            _ picker: UIImagePickerController,
            didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]
        ) {
            if let img = info[.originalImage] as? UIImage {
                parent.image = img
                parent.onSelected(img)
            }
            picker.dismiss(animated: true)
        }
    }
}

// MARK: - TableFieldView

struct TableFieldView: View {
    let field: [String: Any]
    @Binding var value: String  // JSON: [[String: String]]

    private var columns: [String] {
        field["col_headers"] as? [String] ?? ["Column 1"]
    }
    private var rowCount: Int {
        field["table_rows"] as? Int ?? 3
    }

    private var tableData: [[String: String]] {
        get {
            guard let data = value.data(using: .utf8),
                  let array = try? JSONSerialization.jsonObject(with: data) as? [[String: String]]
            else {
                // Initialize empty table
                return Array(repeating: Dictionary(uniqueKeysWithValues: columns.map { ($0, "") }),
                             count: rowCount)
            }
            return array
        }
    }

    private func updateCell(row: Int, col: String, newValue: String) {
        var table = tableData
        while table.count <= row {
            table.append(Dictionary(uniqueKeysWithValues: columns.map { ($0, "") }))
        }
        table[row][col] = newValue
        if let data = try? JSONSerialization.data(withJSONObject: table),
           let str  = String(data: data, encoding: .utf8) {
            value = str
        }
    }

    var body: some View {
        ScrollView(.horizontal) {
            Grid(alignment: .leading, horizontalSpacing: 8, verticalSpacing: 4) {
                // Header row
                GridRow {
                    ForEach(columns, id: \.self) { col in
                        Text(col)
                            .font(.caption)
                            .fontWeight(.semibold)
                            .foregroundStyle(.secondary)
                    }
                }
                Divider()

                // Data rows
                ForEach(0..<rowCount, id: \.self) { rowIdx in
                    GridRow {
                        ForEach(columns, id: \.self) { col in
                            let cellValue = tableData.indices.contains(rowIdx)
                                ? tableData[rowIdx][col] ?? "" : ""
                            TextField("", text: Binding(
                                get: { cellValue },
                                set: { updateCell(row: rowIdx, col: col, newValue: $0) }
                            ))
                            .textFieldStyle(.roundedBorder)
                            .frame(minWidth: 100)
                        }
                    }
                }
            }
            .padding(4)
        }
    }
}