import SwiftUI
import UIKit

/// UIKit owns composition, candidate selection, keyboard switching and dictation.
/// Confirmed text is mirrored to the remote app; preedit stays in the IME.
struct RemoteSystemKeyboard: View {
    @ObservedObject var session: RemoteSessionModel
    @StateObject private var keyboard = RemoteKeyboardController()
    var inputContext: RemoteKeyboardInputContext? = nil
    var geometry: RemoteKeyboardGeometry? = nil
    var animatePresentation = true
    var didPresent: () -> Void = {}
    let switchKeyboard: () -> Void
    let dismiss: () -> Void

    var body: some View {
        RemoteKeyboardHost(
            controller: keyboard,
            edit: session.sendSystemTextEdit,
            inputContext: inputContext,
            geometry: geometry,
            animatePresentation: animatePresentation,
            didPresent: didPresent,
            key: session.sendKeyStroke,
            status: session.keyboardInputStatus,
            switchKeyboard: switchKeyboard,
            dismiss: dismiss
        )
        // The native host tracks the keyboard itself, including its animation.
        // SwiftUI must not also resize it to the keyboard's safe area.
        .ignoresSafeArea()
        .onDisappear { keyboard.stop() }
    }
}

private struct RemoteKeyboardHost: UIViewControllerRepresentable {
    @Environment(\.colorScheme) private var colorScheme
    let controller: RemoteKeyboardController
    let edit: (Int, String) -> Bool
    let inputContext: RemoteKeyboardInputContext?
    let geometry: RemoteKeyboardGeometry?
    let animatePresentation: Bool
    let didPresent: () -> Void
    let key: (UInt) -> Void
    let status: String
    let switchKeyboard: () -> Void
    let dismiss: () -> Void

    func makeUIViewController(context: Context) -> RemoteKeyboardController {
        update(controller)
        return controller
    }

    func updateUIViewController(_ controller: RemoteKeyboardController,
                                context: Context) {
        update(controller)
    }

    private func update(_ controller: RemoteKeyboardController) {
        controller.editor.applyEdit = edit
        inputContext?.editor = controller.editor
        controller.geometry = geometry
        controller.animatePresentation = animatePresentation
        controller.didPresent = didPresent
        controller.editor.key = key
        controller.inputBar.switchKeyboard = { [weak controller] in
            controller?.rememberKeyboardHeight()
            // Let SwiftUI install the replacement panel before teardown hides
            // the native keyboard, avoiding an empty frame between the two.
            controller?.animateDismissal = false
            switchKeyboard()
        }
        controller.inputBar.dismiss = { [weak controller] in
            controller?.stop()
            dismiss()
        }
        controller.overrideUserInterfaceStyle = colorScheme == .dark ? .dark : .light
        controller.inputBar.setStatus(status)
    }

    static func dismantleUIViewController(_ controller: RemoteKeyboardController,
                                          coordinator: ()) {
        controller.stop()
    }
}

final class RemoteKeyboardController: UIViewController, ObservableObject {
    let editor: RemoteTextInputView
    let inputBar: RemoteKeyboardInputBar
    var geometry: RemoteKeyboardGeometry?
    var animatePresentation = true
    var animateDismissal = true
    var didPresent: (() -> Void)?
    private var acceptingInput = true
    private var animationsEnabledBeforePresentation: Bool?

    init() {
        let editor = RemoteTextInputView()
        editor.automaticallyFocus = false
        self.editor = editor
        self.inputBar = RemoteKeyboardInputBar()
        super.init(nibName: nil, bundle: nil)
    }

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

    override func loadView() {
        let host = RemoteKeyboardHostView()
        host.willDetach = { [weak self] in self?.stop() }
        view = host
        view.backgroundColor = .clear
        host.inputBar = inputBar
        inputBar.translatesAutoresizingMaskIntoConstraints = false
        host.addSubview(inputBar)
        // Keep a real UITextField for IME and dictation context, but never
        // display a second copy of the remote text or a local caret.
        editor.isAccessibilityElement = false
        editor.translatesAutoresizingMaskIntoConstraints = false
        host.addSubview(editor)

        // Keep one continuous background behind the row and the system
        // keyboard's rounded corners, without reserving an input accessory slot.
        let backdrop = UIView()
        backdrop.backgroundColor = RemoteKeyboardInputBar.keyboardBackground
        backdrop.isUserInteractionEnabled = false
        backdrop.translatesAutoresizingMaskIntoConstraints = false
        host.insertSubview(backdrop, at: 0)
        NSLayoutConstraint.activate([
            editor.leadingAnchor.constraint(equalTo: inputBar.leadingAnchor),
            editor.topAnchor.constraint(equalTo: inputBar.topAnchor),
            editor.widthAnchor.constraint(equalToConstant: 1),
            editor.heightAnchor.constraint(equalToConstant: 1),
            inputBar.leadingAnchor.constraint(equalTo: host.leadingAnchor),
            inputBar.trailingAnchor.constraint(equalTo: host.trailingAnchor),
            inputBar.bottomAnchor.constraint(equalTo: host.keyboardLayoutGuide.topAnchor),
            backdrop.topAnchor.constraint(equalTo: inputBar.topAnchor),
            backdrop.leadingAnchor.constraint(equalTo: host.leadingAnchor),
            backdrop.trailingAnchor.constraint(equalTo: host.trailingAnchor),
            backdrop.bottomAnchor.constraint(equalTo: host.bottomAnchor)
        ])
    }

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        guard acceptingInput, !editor.isFirstResponder else { return }
        if animatePresentation {
            editor.becomeFirstResponder()
        } else {
            // UIKit may start showing the keyboard after becomeFirstResponder
            // returns. Keep this short suppression alive until it is shown,
            // rather than ending it at the end of a synchronous animation block.
            animationsEnabledBeforePresentation = UIView.areAnimationsEnabled
            NotificationCenter.default.addObserver(
                self, selector: #selector(finishKeyboardPresentation),
                name: UIResponder.keyboardDidShowNotification, object: nil)
            UIView.setAnimationsEnabled(false)
            if !editor.becomeFirstResponder() {
                finishKeyboardPresentation()
            }
            view.layoutIfNeeded()
            // A hardware keyboard or an interrupted focus request may produce
            // no did-show notification. Always restore the previous state.
            // Retain the controller until cleanup even if its host disappears.
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                self.finishKeyboardPresentation()
            }
        }
    }

    @objc private func finishKeyboardPresentation() {
        guard let enabled = animationsEnabledBeforePresentation else { return }
        animationsEnabledBeforePresentation = nil
        NotificationCenter.default.removeObserver(
            self, name: UIResponder.keyboardDidShowNotification, object: nil)
        UIView.setAnimationsEnabled(enabled)
        if acceptingInput {
            DispatchQueue.main.async { [weak self] in
                guard let self, self.acceptingInput else { return }
                self.didPresent?()
            }
        }
    }

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        rememberKeyboardHeight()
    }

    func rememberKeyboardHeight() {
        guard acceptingInput, editor.isFirstResponder else { return }
        let keyboard = view.keyboardLayoutGuide.layoutFrame
        // Ignore hidden, floating and split keyboards: they do not define a
        // full-width docked panel that the computer keyboard can replace.
        guard keyboard.height > 100,
              keyboard.width >= view.bounds.width - 1 else { return }
        geometry?.remember(height: view.bounds.maxY - keyboard.minY +
                            RemoteKeyboardInputBar.barHeight,
                           size: view.bounds.size)
    }

    func stop() {
        guard acceptingInput else { return }
        acceptingInput = false
        finishKeyboardPresentation()
        editor.stop()
        inputBar.switchKeyboard = nil
        inputBar.dismiss = nil
        let dismiss = {
            self.editor.resignFirstResponder()
            self.editor.removeFromSuperview()
        }
        if animateDismissal {
            dismiss()
        } else {
            UIView.performWithoutAnimation(dismiss)
        }
    }
}

/// Retain the last native height for each window width and orientation, even
/// after the text field resigns first responder during a keyboard switch.
final class RemoteKeyboardGeometry: ObservableObject {
    private var heights: [String: CGFloat] = [:]

    private func key(for size: CGSize) -> String {
        "\(Int(size.width.rounded()))-\(size.width > size.height)"
    }

    func remember(height: CGFloat, size: CGSize) {
        heights[key(for: size)] = height
    }

    func panelHeight(in size: CGSize, bottomInset: CGFloat) -> CGFloat {
        // A rotation may reach a size at which the native keyboard has not yet
        // appeared. The compact iPhone keybed is 161 points; using the full
        // 216-point keybed here makes only the first landscape switch jump.
        // Safe-area and toolbar heights are added separately below.
        let fallback: CGFloat = size.width > size.height ? 161 : 300
        let height = heights[key(for: size)] ??
            (fallback + bottomInset + RemoteKeyboardInputBar.barHeight)
        return min(height, size.height)
    }
}

private final class RemoteKeyboardHostView: UIView {
    var willDetach: (() -> Void)?
    weak var inputBar: UIView?

    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
        guard let inputBar else { return nil }
        // Video gestures outside the input row must reach the remote viewport.
        return inputBar.hitTest(convert(point, to: inputBar), with: event)
    }

    override func willMove(toSuperview newSuperview: UIView?) {
        if newSuperview == nil { willDetach?() }
        super.willMove(toSuperview: newSuperview)
    }
}

/// Use the same UIKit symbol layout in both the native and SwiftUI toolbars.
/// Matching font sizes alone still gives their symbols different baselines.
struct RemoteKeyboardDismissButton: UIViewRepresentable {
    static let sideLength: CGFloat = 44
    let accessibilityLabel: String
    let action: () -> Void

    static func makeButton() -> UIButton {
        let button = UIButton(type: .system)
        button.tintColor = .label
        button.setImage(UIImage(systemName: "keyboard.chevron.compact.down"), for: .normal)
        button.setPreferredSymbolConfiguration(
            UIImage.SymbolConfiguration(pointSize: 20, weight: .regular, scale: .medium),
            forImageIn: .normal)
        button.contentHorizontalAlignment = .center
        button.contentVerticalAlignment = .center
        return button
    }

    func makeCoordinator() -> Coordinator { Coordinator(action: action) }

    func makeUIView(context: Context) -> UIButton {
        let button = Self.makeButton()
        button.addTarget(context.coordinator, action: #selector(Coordinator.pressed),
                         for: .touchUpInside)
        return button
    }

    func updateUIView(_ button: UIButton, context: Context) {
        button.accessibilityLabel = accessibilityLabel
        context.coordinator.action = action
    }

    final class Coordinator: NSObject {
        var action: () -> Void

        init(action: @escaping () -> Void) { self.action = action }

        @objc func pressed() { action() }
    }
}

final class RemoteKeyboardInputBar: UIView {
    static let barHeight: CGFloat = 44
    static let keyboardBackground = UIColor { traits in
        traits.userInterfaceStyle == .dark ? .secondarySystemBackground : .systemGray4
    }
    var switchKeyboard: (() -> Void)?
    var dismiss: (() -> Void)?
    private let statusLabel = UILabel()
    private let row = UIStackView()
    private var status = ""
    private var statusHeight: CGFloat = 0
    private var heightConstraint: NSLayoutConstraint!

    init() {
        super.init(frame: .zero)
        backgroundColor = .clear
        tintColor = .label
        heightConstraint = heightAnchor.constraint(equalToConstant: Self.barHeight)
        heightConstraint.isActive = true

        let computerButton = UIButton(type: .system)
        computerButton.setTitle("电脑键盘", for: .normal)
        computerButton.titleLabel?.font = .systemFont(ofSize: 15, weight: .medium)
        computerButton.accessibilityLabel = "切换到电脑键盘"
        computerButton.addTarget(self, action: #selector(switchToComputer), for: .touchUpInside)

        let dismissButton = RemoteKeyboardDismissButton.makeButton()
        dismissButton.accessibilityLabel = "收起系统键盘"
        dismissButton.addTarget(self, action: #selector(hideKeyboard), for: .touchUpInside)

        row.axis = .horizontal
        row.alignment = .fill
        row.spacing = 4
        for item in [computerButton, UIView(), dismissButton] { row.addArrangedSubview(item) }
        row.translatesAutoresizingMaskIntoConstraints = false
        addSubview(row)
        NSLayoutConstraint.activate([
            computerButton.widthAnchor.constraint(equalToConstant: 80),
            dismissButton.widthAnchor.constraint(equalToConstant: RemoteKeyboardDismissButton.sideLength),
            row.leadingAnchor.constraint(equalTo: safeAreaLayoutGuide.leadingAnchor, constant: 4),
            row.trailingAnchor.constraint(equalTo: safeAreaLayoutGuide.trailingAnchor, constant: -4),
            row.bottomAnchor.constraint(equalTo: bottomAnchor),
            row.heightAnchor.constraint(equalToConstant: Self.barHeight)
        ])

        statusLabel.font = .systemFont(ofSize: 12)
        statusLabel.textColor = .secondaryLabel
        statusLabel.numberOfLines = 0
        statusLabel.isHidden = true
        addSubview(statusLabel)
    }

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

    override var intrinsicContentSize: CGSize {
        CGSize(width: UIView.noIntrinsicMetric, height: Self.barHeight + statusHeight)
    }

    func setStatus(_ value: String) {
        guard status != value else { return }
        status = value
        statusLabel.text = value
        statusLabel.isHidden = value.isEmpty
        setNeedsLayout()
    }

    override func layoutSubviews() {
        super.layoutSubviews()
        let inset = max(8, safeAreaInsets.left)
        let width = max(1, bounds.width - inset - max(8, safeAreaInsets.right))
        let height = status.isEmpty ? 0 : ceil(statusLabel.sizeThatFits(
            CGSize(width: width, height: .greatestFiniteMagnitude)).height) + 4
        statusLabel.frame = CGRect(x: inset, y: 2, width: width, height: max(0, height - 4))
        if statusHeight != height {
            statusHeight = height
            heightConstraint.constant = Self.barHeight + height
            invalidateIntrinsicContentSize()
        }
    }

    @objc private func switchToComputer() { switchKeyboard?() }
    @objc private func hideKeyboard() { dismiss?() }
}

/// Resets the local IME context synchronously before a remote click can move
/// the insertion point. Nothing typed at the old location may be rewritten there.
final class RemoteKeyboardInputContext: ObservableObject {
    weak var editor: RemoteTextInputView?

    func remoteFocusWillChange() {
        editor?.finishInputContext()
    }
}

final class RemoteTextInputView: UITextField, UITextFieldDelegate {
    var applyEdit: ((Int, String) -> Bool)?
    var key: ((UInt) -> Void)?
    private(set) var acceptingInput = true
    var automaticallyFocus = true
    private var sentText = ""
    private var changeScheduled = false
    private var resetting = false
    private var generation: UInt64 = 0

    override var canBecomeFirstResponder: Bool { acceptingInput && super.canBecomeFirstResponder }

    init() {
        super.init(frame: .zero)
        delegate = self
        textColor = .clear
        tintColor = .clear
        backgroundColor = .clear
        borderStyle = .none
        keyboardType = .default
        returnKeyType = .default
        autocorrectionType = .default
        autocapitalizationType = .none
        spellCheckingType = .default
        smartQuotesType = .no
        smartDashesType = .no
        smartInsertDeleteType = .no
        inputAssistantItem.leadingBarButtonGroups = []
        inputAssistantItem.trailingBarButtonGroups = []
        addTarget(self, action: #selector(scheduleTextChange), for: .editingChanged)
    }

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

    override func didMoveToWindow() {
        super.didMoveToWindow()
        if window != nil && acceptingInput && automaticallyFocus { becomeFirstResponder() }
    }

    override func caretRect(for position: UITextPosition) -> CGRect { .zero }
    override func selectionRects(for range: UITextRange) -> [UITextSelectionRect] { [] }

    func textFieldDidChangeSelection(_ textField: UITextField) { scheduleTextChange() }

    override func insertText(_ text: String) {
        guard acceptingInput else { return }
        if (text == "\n" || text == "\r") && markedTextRange == nil {
            _ = textFieldShouldReturn(self)
            return
        }
        super.insertText(text)
        scheduleTextChange()
    }

    override func replace(_ range: UITextRange, withText text: String) {
        guard acceptingInput else { return }
        super.replace(range, withText: text)
        scheduleTextChange()
    }

    override func setMarkedText(_ markedText: String?, selectedRange: NSRange) {
        guard acceptingInput else { return }
        super.setMarkedText(markedText, selectedRange: selectedRange)
        scheduleTextChange()
    }

    override func unmarkText() {
        super.unmarkText()
        scheduleTextChange()
    }

    override func deleteBackward() {
        guard acceptingInput else { return }
        if !hasText && markedTextRange == nil {
            // Flush any pending deletion before deleting beyond local context.
            if synchronizeText() { key?(0x08) }
        } else {
            super.deleteBackward()
            scheduleTextChange()
        }
    }

    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        guard acceptingInput, markedTextRange == nil else { return false }
        if synchronizeText() {
            key?(0x0d)
            resetContext()
        }
        return false
    }

    @objc private func scheduleTextChange() {
        guard acceptingInput, !resetting, !changeScheduled else { return }
        changeScheduled = true
        let currentGeneration = generation
        // UIKit may replace text and clear markedTextRange in separate calls.
        // Wait one run-loop turn so only the completed IME transaction is sent.
        DispatchQueue.main.async { [weak self] in
            guard let self, self.generation == currentGeneration else { return }
            self.changeScheduled = false
            _ = self.synchronizeText()
        }
    }

    @discardableResult
    func synchronizeText() -> Bool {
        guard acceptingInput, !resetting, markedTextRange == nil else { return false }
        let current = text ?? ""
        guard current != sentText else { return true }
        let prefixCount = zip(sentText, current).prefix(while: { $0 == $1 }).count
        let deleteCount = sentText.count - prefixCount
        let insertion = String(current.dropFirst(prefixCount))
        guard applyEdit?(deleteCount, insertion) == true else {
            // Do not keep invisible rejected input to replay on a later key.
            resetContext()
            return false
        }
        sentText = current
        return true
    }

    func finishInputContext() {
        guard acceptingInput else { return }
        _ = synchronizeText()
        resetContext()
    }

    func stop() {
        acceptingInput = false
        applyEdit = nil
        key = nil
        resetContext()
    }

    private func resetContext() {
        generation &+= 1
        changeScheduled = false
        resetting = true
        super.unmarkText()
        text = ""
        sentText = ""
        resetting = false
    }
}