import UIKit
import ExpoModulesCore

// MARK: - UI Delegate Protocol
@objc public protocol ImageEditorUIDelegate: AnyObject {
    @objc optional func imageEditorDidLoad(_ controller: ImageEditorUIViewController)
    @objc optional func imageEditorDidChange(_ controller: ImageEditorUIViewController)
    @objc optional func imageEditorDidExport(_ controller: ImageEditorUIViewController, fileURL: URL)
    @objc optional func imageEditorDidError(_ controller: ImageEditorUIViewController, error: Error)
    @objc optional func imageEditorDidClose(_ controller: ImageEditorUIViewController)
}

// MARK: - Main UI Controller
public class ImageEditorUIViewController: UIViewController {

    // MARK: - Properties
    public let engine: ImageEditorEngine
    private var config: ImageEditorUIConfig

    public weak var delegate: ImageEditorUIDelegate?

    // UI Components
    private let imageView: ImageEditorView
    private let scrollView: UIScrollView
    private var topToolbar: UIView!
    private var bottomToolbar: UIView!
    private var adjustmentPanel: UIView?
    private var filterPanel: UIView?
    private var layerPanel: UIView?
    private var drawingPanel: UIView?

    // State
    private var currentTool: EditorTool = .none
    private var selectedLayer: ImageLayer?
    private var isDrawing = false

    // Constants
    private let toolbarHeight: CGFloat = 60
    private let panelHeight: CGFloat = 200

    // MARK: - Initialization
    public init(config: ImageEditorUIConfig = ImageEditorUIConfig()) {
        self.config = config
        self.engine = ImageEditorEngine()
        self.imageView = ImageEditorView(frame: .zero)
        self.scrollView = UIScrollView()

        super.init(nibName: nil, bundle: nil)

        imageView.engine = engine
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    // MARK: - Lifecycle
    public override func viewDidLoad() {
        super.viewDidLoad()

        setupUI()
        setupGestures()
        setupNotifications()

        delegate?.imageEditorDidLoad?(self)
    }

    // MARK: - Public API
    public func loadImage(from path: String) {
        do {
            _ = try engine.loadImage(from: path)
            imageView.setNeedsDisplay()
            delegate?.imageEditorDidChange?(self)
        } catch {
            delegate?.imageEditorDidError?(self, error: error)
        }
    }

    public func updateConfig(_ config: ImageEditorUIConfig) {
        self.config = config
        refreshUI()
    }

    // MARK: - UI Setup
    private func setupUI() {
        view.backgroundColor = config.backgroundColor

        // Setup scroll view
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.minimumZoomScale = 0.5
        scrollView.maximumZoomScale = 5.0
        scrollView.delegate = self
        view.addSubview(scrollView)

        // Setup image view
        imageView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.addSubview(imageView)

        // Setup toolbars
        if config.showTopToolbar {
            setupTopToolbar()
        }

        if config.showBottomToolbar {
            setupBottomToolbar()
        }

        // Layout constraints
        setupConstraints()
    }

    private func setupTopToolbar() {
        topToolbar = UIView()
        topToolbar.backgroundColor = config.toolbarBackgroundColor
        topToolbar.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(topToolbar)

        // Close button
        let closeButton = createButton(
            title: "Close",
            icon: UIImage(systemName: "xmark"),
            action: #selector(closeButtonTapped)
        )

        // Undo/Redo buttons
        let undoButton = createButton(
            title: nil,
            icon: UIImage(systemName: "arrow.uturn.backward"),
            action: #selector(undoButtonTapped)
        )

        let redoButton = createButton(
            title: nil,
            icon: UIImage(systemName: "arrow.uturn.forward"),
            action: #selector(redoButtonTapped)
        )

        // Reset button
        let resetButton = createButton(
            title: "Reset",
            icon: UIImage(systemName: "arrow.counterclockwise"),
            action: #selector(resetButtonTapped)
        )

        // Export button
        let exportButton = createButton(
            title: "Export",
            icon: UIImage(systemName: "square.and.arrow.up"),
            action: #selector(exportButtonTapped)
        )
        exportButton.tintColor = config.accentColor

        let stackView = UIStackView(arrangedSubviews: [
            closeButton,
            UIView(), // Spacer
            undoButton,
            redoButton,
            resetButton,
            exportButton
        ])
        stackView.axis = .horizontal
        stackView.spacing = 16
        stackView.translatesAutoresizingMaskIntoConstraints = false
        topToolbar.addSubview(stackView)

        NSLayoutConstraint.activate([
            stackView.leadingAnchor.constraint(equalTo: topToolbar.leadingAnchor, constant: 16),
            stackView.trailingAnchor.constraint(equalTo: topToolbar.trailingAnchor, constant: -16),
            stackView.topAnchor.constraint(equalTo: topToolbar.topAnchor, constant: 8),
            stackView.bottomAnchor.constraint(equalTo: topToolbar.bottomAnchor, constant: -8)
        ])
    }

    private func setupBottomToolbar() {
        bottomToolbar = UIView()
        bottomToolbar.backgroundColor = config.toolbarBackgroundColor
        bottomToolbar.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(bottomToolbar)

        var tools: [UIButton] = []

        if config.enableAdjustments {
            let adjustBtn = createToolButton(
                icon: UIImage(systemName: "slider.horizontal.3"),
                tool: .adjustments
            )
            tools.append(adjustBtn)
        }

        if config.enableFilters {
            let filterBtn = createToolButton(
                icon: UIImage(systemName: "camera.filters"),
                tool: .filters
            )
            tools.append(filterBtn)
        }

        if config.enableTransforms {
            let transformBtn = createToolButton(
                icon: UIImage(systemName: "crop.rotate"),
                tool: .transforms
            )
            tools.append(transformBtn)
        }

        if config.enableLayers {
            let layerBtn = createToolButton(
                icon: UIImage(systemName: "square.on.square"),
                tool: .layers
            )
            tools.append(layerBtn)
        }

        if config.enableDrawing {
            let drawBtn = createToolButton(
                icon: UIImage(systemName: "pencil.tip"),
                tool: .drawing
            )
            tools.append(drawBtn)
        }

        if config.enableText {
            let textBtn = createToolButton(
                icon: UIImage(systemName: "textformat"),
                tool: .text
            )
            tools.append(textBtn)
        }

        if config.enableStickers {
            let stickerBtn = createToolButton(
                icon: UIImage(systemName: "face.smiling"),
                tool: .stickers
            )
            tools.append(stickerBtn)
        }

        let stackView = UIStackView(arrangedSubviews: tools)
        stackView.axis = .horizontal
        stackView.distribution = .equalSpacing
        stackView.alignment = .center
        stackView.translatesAutoresizingMaskIntoConstraints = false
        bottomToolbar.addSubview(stackView)

        NSLayoutConstraint.activate([
            stackView.leadingAnchor.constraint(equalTo: bottomToolbar.leadingAnchor, constant: 16),
            stackView.trailingAnchor.constraint(equalTo: bottomToolbar.trailingAnchor, constant: -16),
            stackView.centerYAnchor.constraint(equalTo: bottomToolbar.centerYAnchor)
        ])
    }

    private func setupConstraints() {
        var constraints: [NSLayoutConstraint] = []

        // Scroll view constraints
        if config.showTopToolbar {
            constraints.append(scrollView.topAnchor.constraint(equalTo: topToolbar.bottomAnchor))
            constraints.append(topToolbar.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor))
            constraints.append(topToolbar.leadingAnchor.constraint(equalTo: view.leadingAnchor))
            constraints.append(topToolbar.trailingAnchor.constraint(equalTo: view.trailingAnchor))
            constraints.append(topToolbar.heightAnchor.constraint(equalToConstant: toolbarHeight))
        } else {
            constraints.append(scrollView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor))
        }

        if config.showBottomToolbar {
            constraints.append(scrollView.bottomAnchor.constraint(equalTo: bottomToolbar.topAnchor))
            constraints.append(bottomToolbar.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor))
            constraints.append(bottomToolbar.leadingAnchor.constraint(equalTo: view.leadingAnchor))
            constraints.append(bottomToolbar.trailingAnchor.constraint(equalTo: view.trailingAnchor))
            constraints.append(bottomToolbar.heightAnchor.constraint(equalToConstant: toolbarHeight))
        } else {
            constraints.append(scrollView.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor))
        }

        constraints.append(contentsOf: [
            scrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),

            imageView.topAnchor.constraint(equalTo: scrollView.topAnchor),
            imageView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor),
            imageView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor),
            imageView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor),
            imageView.widthAnchor.constraint(equalTo: scrollView.widthAnchor),
            imageView.heightAnchor.constraint(equalTo: scrollView.heightAnchor)
        ])

        NSLayoutConstraint.activate(constraints)
    }

    // MARK: - Button Actions
    @objc private func closeButtonTapped() {
        delegate?.imageEditorDidClose?(self)
        dismiss(animated: true)
    }

    @objc private func undoButtonTapped() {
        do {
            try engine.undo()
            imageView.setNeedsDisplay()
            delegate?.imageEditorDidChange?(self)
        } catch {
            delegate?.imageEditorDidError?(self, error: error)
        }
    }

    @objc private func redoButtonTapped() {
        do {
            try engine.redo()
            imageView.setNeedsDisplay()
            delegate?.imageEditorDidChange?(self)
        } catch {
            delegate?.imageEditorDidError?(self, error: error)
        }
    }

    @objc private func resetButtonTapped() {
        let alert = UIAlertController(
            title: "Reset Image",
            message: "Are you sure you want to reset all changes?",
            preferredStyle: .alert
        )

        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
        alert.addAction(UIAlertAction(title: "Reset", style: .destructive) { [weak self] _ in
            guard let self = self else { return }
            // Reset by reloading original image
            if let sourceImage = self.engine.sourceImage {
                let uiImage = UIImage(ciImage: sourceImage)
                self.engine.loadImage(uiImage)
                self.imageView.setNeedsDisplay()
                self.delegate?.imageEditorDidChange?(self)
            }
        })

        present(alert, animated: true)
    }

    @objc private func exportButtonTapped() {
        showExportOptions()
    }

    @objc private func toolButtonTapped(_ sender: UIButton) {
        guard let tool = EditorTool(rawValue: sender.tag) else { return }
        selectTool(tool)
    }

    // MARK: - Tool Management
    private func selectTool(_ tool: EditorTool) {
        // Hide current panel
        hideAllPanels()

        // Update tool
        currentTool = tool

        // Show appropriate panel
        switch tool {
        case .adjustments:
            showAdjustmentPanel()
        case .filters:
            showFilterPanel()
        case .transforms:
            showTransformPanel()
        case .layers:
            showLayerPanel()
        case .drawing:
            showDrawingPanel()
        case .text:
            showTextPanel()
        case .stickers:
            showStickerPanel()
        case .none:
            break
        }
    }

    private func hideAllPanels() {
        adjustmentPanel?.removeFromSuperview()
        filterPanel?.removeFromSuperview()
        layerPanel?.removeFromSuperview()
        drawingPanel?.removeFromSuperview()
        adjustmentPanel = nil
        filterPanel = nil
        layerPanel = nil
        drawingPanel = nil
    }

    // MARK: - Adjustment Panel
    private func showAdjustmentPanel() {
        let panel = createPanel()
        adjustmentPanel = panel

        let scrollView = UIScrollView()
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        panel.addSubview(scrollView)

        let contentView = UIStackView()
        contentView.axis = .vertical
        contentView.spacing = 12
        contentView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.addSubview(contentView)

        // Add sliders for each adjustment
        let adjustments: [(String, String, Float, Float)] = [
            ("Brightness", "brightness", -1.0, 1.0),
            ("Contrast", "contrast", 0.5, 1.5),
            ("Saturation", "saturation", 0.0, 2.0),
            ("Exposure", "exposure", -2.0, 2.0),
            ("Temperature", "temperature", -1.0, 1.0),
            ("Tint", "tint", -1.0, 1.0),
            ("Highlights", "highlights", -1.0, 1.0),
            ("Shadows", "shadows", -1.0, 1.0),
            ("Sharpness", "sharpness", 0.0, 2.0),
            ("Vignette", "vignette", 0.0, 2.0)
        ]

        for (label, key, min, max) in adjustments {
            let slider = createAdjustmentSlider(
                label: label,
                key: key,
                min: min,
                max: max
            )
            contentView.addArrangedSubview(slider)
        }

        NSLayoutConstraint.activate([
            scrollView.topAnchor.constraint(equalTo: panel.topAnchor),
            scrollView.leadingAnchor.constraint(equalTo: panel.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: panel.trailingAnchor),
            scrollView.bottomAnchor.constraint(equalTo: panel.bottomAnchor),

            contentView.topAnchor.constraint(equalTo: scrollView.topAnchor, constant: 16),
            contentView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor, constant: 16),
            contentView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor, constant: -16),
            contentView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor, constant: -16),
            contentView.widthAnchor.constraint(equalTo: scrollView.widthAnchor, constant: -32)
        ])
    }

    private func createAdjustmentSlider(label: String, key: String, min: Float, max: Float) -> UIView {
        let container = UIView()
        container.translatesAutoresizingMaskIntoConstraints = false

        let titleLabel = UILabel()
        titleLabel.text = label
        titleLabel.font = UIFont.systemFont(ofSize: 14, weight: .medium)
        titleLabel.textColor = config.textColor
        titleLabel.translatesAutoresizingMaskIntoConstraints = false

        let valueLabel = UILabel()
        valueLabel.text = "0.0"
        valueLabel.font = UIFont.monospacedSystemFont(ofSize: 12, weight: .regular)
        valueLabel.textColor = config.secondaryTextColor
        valueLabel.translatesAutoresizingMaskIntoConstraints = false

        let slider = UISlider()
        slider.minimumValue = min
        slider.maximumValue = max
        slider.value = (min + max) / 2
        slider.tintColor = config.accentColor
        slider.translatesAutoresizingMaskIntoConstraints = false
        slider.accessibilityIdentifier = key
        slider.addTarget(self, action: #selector(adjustmentSliderChanged), for: .valueChanged)

        container.addSubview(titleLabel)
        container.addSubview(valueLabel)
        container.addSubview(slider)

        NSLayoutConstraint.activate([
            titleLabel.topAnchor.constraint(equalTo: container.topAnchor),
            titleLabel.leadingAnchor.constraint(equalTo: container.leadingAnchor),

            valueLabel.topAnchor.constraint(equalTo: container.topAnchor),
            valueLabel.trailingAnchor.constraint(equalTo: container.trailingAnchor),

            slider.topAnchor.constraint(equalTo: titleLabel.bottomAnchor, constant: 8),
            slider.leadingAnchor.constraint(equalTo: container.leadingAnchor),
            slider.trailingAnchor.constraint(equalTo: container.trailingAnchor),
            slider.bottomAnchor.constraint(equalTo: container.bottomAnchor),

            container.heightAnchor.constraint(equalToConstant: 60)
        ])

        return container
    }

    @objc private func adjustmentSliderChanged(_ slider: UISlider) {
        guard let key = slider.accessibilityIdentifier else { return }

        // Update value label
        if let container = slider.superview,
           let valueLabel = container.subviews.compactMap({ $0 as? UILabel }).last {
            valueLabel.text = String(format: "%.2f", slider.value)
        }

        // Apply adjustment
        var adjustments = ImageAdjustments()

        switch key {
        case "brightness": adjustments.brightness = slider.value
        case "contrast": adjustments.contrast = slider.value
        case "saturation": adjustments.saturation = slider.value
        case "exposure": adjustments.exposure = slider.value
        case "temperature": adjustments.temperature = slider.value
        case "tint": adjustments.tint = slider.value
        case "highlights": adjustments.highlights = slider.value
        case "shadows": adjustments.shadows = slider.value
        case "sharpness": adjustments.sharpness = slider.value
        case "vignette": adjustments.vignette = slider.value
        default: break
        }

        do {
            try engine.applyAdjustments(adjustments)
            imageView.setNeedsDisplay()
            delegate?.imageEditorDidChange?(self)
        } catch {
            delegate?.imageEditorDidError?(self, error: error)
        }
    }

    // MARK: - Filter Panel
    private func showFilterPanel() {
        let panel = createPanel()
        filterPanel = panel

        let scrollView = UIScrollView()
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.showsHorizontalScrollIndicator = false
        panel.addSubview(scrollView)

        let stackView = UIStackView()
        stackView.axis = .horizontal
        stackView.spacing = 12
        stackView.translatesAutoresizingMaskIntoConstraints = false
        scrollView.addSubview(stackView)

        // Add filter buttons
        let filters = FilterPreset.allCases

        for filter in filters {
            let button = createFilterButton(name: filter.rawValue)
            stackView.addArrangedSubview(button)
        }

        NSLayoutConstraint.activate([
            scrollView.topAnchor.constraint(equalTo: panel.topAnchor, constant: 16),
            scrollView.leadingAnchor.constraint(equalTo: panel.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: panel.trailingAnchor),
            scrollView.heightAnchor.constraint(equalToConstant: 120),

            stackView.topAnchor.constraint(equalTo: scrollView.topAnchor),
            stackView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor, constant: 16),
            stackView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor, constant: -16),
            stackView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor),
            stackView.heightAnchor.constraint(equalTo: scrollView.heightAnchor)
        ])
    }

    private func createFilterButton(name: String) -> UIButton {
        let button = UIButton(type: .system)
        button.setTitle(name.capitalized, for: .normal)
        button.setTitleColor(config.textColor, for: .normal)
        button.backgroundColor = config.secondaryBackgroundColor
        button.layer.cornerRadius = 8
        button.titleLabel?.font = UIFont.systemFont(ofSize: 14, weight: .medium)
        button.contentEdgeInsets = UIEdgeInsets(top: 8, left: 16, bottom: 8, right: 16)
        button.accessibilityIdentifier = name
        button.addTarget(self, action: #selector(filterButtonTapped), for: .touchUpInside)

        NSLayoutConstraint.activate([
            button.widthAnchor.constraint(equalToConstant: 100),
            button.heightAnchor.constraint(equalToConstant: 100)
        ])

        return button
    }

    @objc private func filterButtonTapped(_ sender: UIButton) {
        guard let filterName = sender.accessibilityIdentifier,
              let filterPreset = FilterPreset(rawValue: filterName) else { return }

        _ = engine.applyFilter(filterPreset, intensity: 1.0)
        imageView.setNeedsDisplay()
        delegate?.imageEditorDidChange?(self)
    }

    // MARK: - Transform Panel
    private func showTransformPanel() {
        let panel = createPanel()

        let stackView = UIStackView()
        stackView.axis = .horizontal
        stackView.distribution = .fillEqually
        stackView.spacing = 12
        stackView.translatesAutoresizingMaskIntoConstraints = false
        panel.addSubview(stackView)

        let cropBtn = createActionButton(title: "Crop", icon: UIImage(systemName: "crop"), action: #selector(cropButtonTapped))
        let rotateBtn = createActionButton(title: "Rotate", icon: UIImage(systemName: "rotate.right"), action: #selector(rotateButtonTapped))
        let flipHBtn = createActionButton(title: "Flip H", icon: UIImage(systemName: "flip.horizontal"), action: #selector(flipHorizontalButtonTapped))
        let flipVBtn = createActionButton(title: "Flip V", icon: UIImage(systemName: "arrow.up.and.down"), action: #selector(flipVerticalButtonTapped))

        stackView.addArrangedSubview(cropBtn)
        stackView.addArrangedSubview(rotateBtn)
        stackView.addArrangedSubview(flipHBtn)
        stackView.addArrangedSubview(flipVBtn)

        NSLayoutConstraint.activate([
            stackView.centerYAnchor.constraint(equalTo: panel.centerYAnchor),
            stackView.leadingAnchor.constraint(equalTo: panel.leadingAnchor, constant: 16),
            stackView.trailingAnchor.constraint(equalTo: panel.trailingAnchor, constant: -16),
            stackView.heightAnchor.constraint(equalToConstant: 80)
        ])
    }

    @objc private func cropButtonTapped() {
        // Show crop interface
        showAlert(title: "Crop", message: "Crop functionality - implement custom crop UI")
    }

    @objc private func rotateButtonTapped() {
        _ = engine.rotate(by: 90)
        imageView.setNeedsDisplay()
        delegate?.imageEditorDidChange?(self)
    }

    @objc private func flipHorizontalButtonTapped() {
        do {
            try engine.flipHorizontal()
            imageView.setNeedsDisplay()
            delegate?.imageEditorDidChange?(self)
        } catch {
            delegate?.imageEditorDidError?(self, error: error)
        }
    }

    @objc private func flipVerticalButtonTapped() {
        do {
            try engine.flipVertical()
            imageView.setNeedsDisplay()
            delegate?.imageEditorDidChange?(self)
        } catch {
            delegate?.imageEditorDidError?(self, error: error)
        }
    }

    // MARK: - Layer Panel
    private func showLayerPanel() {
        let panel = createPanel()
        layerPanel = panel

        let label = UILabel()
        label.text = "Layer Management"
        label.font = UIFont.systemFont(ofSize: 16, weight: .semibold)
        label.textColor = config.textColor
        label.textAlignment = .center
        label.translatesAutoresizingMaskIntoConstraints = false
        panel.addSubview(label)

        NSLayoutConstraint.activate([
            label.centerXAnchor.constraint(equalTo: panel.centerXAnchor),
            label.centerYAnchor.constraint(equalTo: panel.centerYAnchor)
        ])
    }

    // MARK: - Drawing Panel
    private func showDrawingPanel() {
        let panel = createPanel()
        drawingPanel = panel

        imageView.drawingEnabled = true

        let label = UILabel()
        label.text = "Draw on the image"
        label.font = UIFont.systemFont(ofSize: 16, weight: .semibold)
        label.textColor = config.textColor
        label.textAlignment = .center
        label.translatesAutoresizingMaskIntoConstraints = false
        panel.addSubview(label)

        NSLayoutConstraint.activate([
            label.centerXAnchor.constraint(equalTo: panel.centerXAnchor),
            label.centerYAnchor.constraint(equalTo: panel.centerYAnchor)
        ])
    }

    // MARK: - Text Panel
    private func showTextPanel() {
        let panel = createPanel()

        let label = UILabel()
        label.text = "Text Tool"
        label.font = UIFont.systemFont(ofSize: 16, weight: .semibold)
        label.textColor = config.textColor
        label.textAlignment = .center
        label.translatesAutoresizingMaskIntoConstraints = false
        panel.addSubview(label)

        NSLayoutConstraint.activate([
            label.centerXAnchor.constraint(equalTo: panel.centerXAnchor),
            label.centerYAnchor.constraint(equalTo: panel.centerYAnchor)
        ])
    }

    // MARK: - Sticker Panel
    private func showStickerPanel() {
        let panel = createPanel()

        let label = UILabel()
        label.text = "Stickers"
        label.font = UIFont.systemFont(ofSize: 16, weight: .semibold)
        label.textColor = config.textColor
        label.textAlignment = .center
        label.translatesAutoresizingMaskIntoConstraints = false
        panel.addSubview(label)

        NSLayoutConstraint.activate([
            label.centerXAnchor.constraint(equalTo: panel.centerXAnchor),
            label.centerYAnchor.constraint(equalTo: panel.centerYAnchor)
        ])
    }

    // MARK: - Export Options
    private func showExportOptions() {
        let alert = UIAlertController(
            title: "Export Image",
            message: "Choose export format and quality",
            preferredStyle: .actionSheet
        )

        if config.allowedExportFormats.contains("jpeg") {
            alert.addAction(UIAlertAction(title: "JPEG (High Quality)", style: .default) { [weak self] _ in
                self?.exportImage(format: "jpeg", quality: 0.9)
            })
        }

        if config.allowedExportFormats.contains("png") {
            alert.addAction(UIAlertAction(title: "PNG (Lossless)", style: .default) { [weak self] _ in
                self?.exportImage(format: "png", quality: 1.0)
            })
        }

        if config.allowedExportFormats.contains("heic") {
            alert.addAction(UIAlertAction(title: "HEIC (High Efficiency)", style: .default) { [weak self] _ in
                self?.exportImage(format: "heic", quality: 0.85)
            })
        }

        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))

        present(alert, animated: true)
    }

    private func exportImage(format: String, quality: Float) {
        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
            guard let self = self else { return }

            do {
                let exportFormat: ExportFormat = (format == "png") ? .png : .jpeg
                let options = ImageEditorEngine.ExportOptions(
                    format: exportFormat,
                    quality: quality,
                    maxDimension: self.config.maxExportDimension
                )

                let data = try self.engine.export(options: options)

                // Save to temp file
                let tempURL = FileManager.default.temporaryDirectory
                    .appendingPathComponent("export.\(format)")

                try data.write(to: tempURL)

                DispatchQueue.main.async {
                    self.delegate?.imageEditorDidExport?(self, fileURL: tempURL)
                    self.showAlert(title: "Success", message: "Image exported successfully")
                }
            } catch {
                DispatchQueue.main.async {
                    self.delegate?.imageEditorDidError?(self, error: error)
                }
            }
        }
    }

    // MARK: - Gestures
    private func setupGestures() {
        // Gestures are handled by ImageEditorView
    }

    // MARK: - Notifications
    private func setupNotifications() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleMemoryWarning),
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )
    }

    @objc private func handleMemoryWarning() {
        showAlert(title: "Memory Warning", message: "Low memory detected. Some features may be limited.")
    }

    // MARK: - Helper Methods
    private func createPanel() -> UIView {
        let panel = UIView()
        panel.backgroundColor = config.toolbarBackgroundColor
        panel.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(panel)

        NSLayoutConstraint.activate([
            panel.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            panel.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            panel.bottomAnchor.constraint(equalTo: bottomToolbar.topAnchor),
            panel.heightAnchor.constraint(equalToConstant: panelHeight)
        ])

        return panel
    }

    private func createButton(title: String?, icon: UIImage?, action: Selector) -> UIButton {
        let button = UIButton(type: .system)

        if let title = title {
            button.setTitle(title, for: .normal)
        }

        if let icon = icon {
            button.setImage(icon, for: .normal)
        }

        button.tintColor = config.textColor
        button.addTarget(self, action: action, for: .touchUpInside)

        return button
    }

    private func createToolButton(icon: UIImage?, tool: EditorTool) -> UIButton {
        let button = UIButton(type: .system)
        button.setImage(icon, for: .normal)
        button.tintColor = config.textColor
        button.tag = tool.rawValue
        button.addTarget(self, action: #selector(toolButtonTapped), for: .touchUpInside)

        NSLayoutConstraint.activate([
            button.widthAnchor.constraint(equalToConstant: 44),
            button.heightAnchor.constraint(equalToConstant: 44)
        ])

        return button
    }

    private func createActionButton(title: String, icon: UIImage?, action: Selector) -> UIButton {
        let button = UIButton(type: .system)
        button.setTitle(title, for: .normal)
        button.setImage(icon, for: .normal)
        button.setTitleColor(config.textColor, for: .normal)
        button.tintColor = config.textColor
        button.backgroundColor = config.secondaryBackgroundColor
        button.layer.cornerRadius = 8
        button.addTarget(self, action: action, for: .touchUpInside)

        // Stack icon and title vertically
        button.titleLabel?.font = UIFont.systemFont(ofSize: 12, weight: .medium)
        button.imageView?.contentMode = .scaleAspectFit

        if #available(iOS 15.0, *) {
            var config = UIButton.Configuration.plain()
            config.imagePlacement = .top
            config.imagePadding = 8
            button.configuration = config
        }

        return button
    }

    private func refreshUI() {
        // Rebuild UI based on updated config
        topToolbar?.removeFromSuperview()
        bottomToolbar?.removeFromSuperview()
        hideAllPanels()

        if config.showTopToolbar {
            setupTopToolbar()
        }

        if config.showBottomToolbar {
            setupBottomToolbar()
        }

        setupConstraints()
    }

    private func showAlert(title: String, message: String) {
        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default))
        present(alert, animated: true)
    }
}

// MARK: - UIScrollViewDelegate
extension ImageEditorUIViewController: UIScrollViewDelegate {
    public func viewForZooming(in scrollView: UIScrollView) -> UIView? {
        return imageView
    }
}

// MARK: - Editor Tool Enum
enum EditorTool: Int {
    case none = 0
    case adjustments = 1
    case filters = 2
    case transforms = 3
    case layers = 4
    case drawing = 5
    case text = 6
    case stickers = 7
}