Lanu_iOS/Lanu/Common/Views/LNPopupView.swift

//
//  LNPopupView.swift
//  Lanu
//
//  Created by OneeChan on 2025/11/14.
//

import Foundation
import UIKit
import SnapKit

enum LNPopupViewHeight {
    case auto
    case percent(CGFloat)
    case height(CGFloat)
}

class LNPopupView: UIView {
    let container = UIView()
    var containerHeight: LNPopupViewHeight = .auto
    var touchOutsideToCancel = true
    var onTouchOutside: (() -> Void)?
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        
        setupViews()
    }
    
    func popup(_ targetView: UIView? = nil) {
        let parentView: UIView? = if let window = targetView as? UIWindow {
            window
        } else if let view = targetView?.viewController?.view {
            view
        } else if let window = UIView.appKeyWindow {
            window
        } else {
            nil
        }
        guard let parentView else { return }
        
        frame = parentView.bounds
        parentView.addSubview(self)
        snp.makeConstraints { make in
            make.edges.equalToSuperview()
        }
        layoutIfNeeded()
        
        moveToShowupPosition()
        window?.endEditing(true)
        backgroundColor = .clear
        UIView.animate(withDuration: 0.2) {
            self.backgroundColor = .black.withAlphaComponent(0.4)
            self.layoutIfNeeded()
        }
    }
    
    func dismiss() {
        endEditing(true)
        moveToHiddenPosition()
        UIView.animate(withDuration: 0.2) {
            self.backgroundColor = .clear
            self.layoutIfNeeded()
        } completion: { [weak self] _ in
            guard let self else { return }
            self.removeFromSuperview()
        }
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

extension LNPopupView {
    private func setupViews() {
        let bg = UIView()
        bg.onTap { [weak self] in
            guard let self else { return }
            if LNKeyboardManager.shared.isEditing {
                endEditing(true)
            } else if touchOutsideToCancel {
                if let onTouchOutside {
                    onTouchOutside()
                } else {
                    dismiss()
                }
            } else {
                endEditing(true)
            }
        }
        insertSubview(bg, at: 0)
        bg.snp.makeConstraints { make in
            make.edges.equalToSuperview()
        }
        
        container.backgroundColor = .white
        container.layer.cornerRadius = 20
        container.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
        addSubview(container)
        moveToHiddenPosition()
        
        let dismissView = UIView()
        container.addSubview(dismissView)
        dismissView.snp.makeConstraints { make in
            make.edges.equalToSuperview()
        }
        dismissView.onTap { [weak self] in
            guard let self else { return }
            endEditing(true)
        }
        
        LNEventDeliver.addObserver(self)
    }
    
    private func moveToHiddenPosition() {
        container.snp.remakeConstraints { make in
            make.leading.trailing.equalToSuperview()
            make.top.equalTo(self.snp.bottom)
            switch containerHeight {
            case .percent(let percent):
                make.height.equalToSuperview().multipliedBy(percent)
            case .height(let height):
                make.height.equalTo(height)
            case .auto: break
            }
        }
    }
    
    private func moveToShowupPosition() {
        container.snp.remakeConstraints { make in
            make.leading.trailing.bottom.equalToSuperview()
            switch containerHeight {
            case .percent(let percent):
                make.height.equalToSuperview().multipliedBy(percent)
            case .height(let height):
                make.height.equalTo(height)
            case .auto: break
            }
        }
    }
    
    private func onKeyboardShowup(_ keyboardHeight: CGFloat) {
        container.snp.remakeConstraints { make in
            make.leading.trailing.equalToSuperview()
            switch containerHeight {
            case .percent(let percent):
                make.height.equalToSuperview().multipliedBy(percent)
            case .height(let height):
                make.height.equalTo(height)
            case .auto: break
            }
            make.bottom.equalToSuperview().offset(-keyboardHeight)
        }
    }
}

extension LNPopupView: LNKeyboardNotify {
    func onKeyboardWillShow(curInput: UIView?, keyboardHeight: CGFloat) {
        guard let curInput, curInput.isDescendant(of: self) == true else { return }
        let containerY = bounds.height - container.bounds.height
        let editViewY = curInput.convert(curInput.bounds, to: container).maxY
        
        let offset = bounds.height - (containerY + editViewY) - keyboardHeight - 16
        
        if offset < 0 {
            onKeyboardShowup(-offset)
        }
    }
    
    func onKeyboardShow(curInput: UIView?, keyboardHeight: CGFloat) {
        guard curInput?.isDescendant(of: self) == true else { return }
        layoutIfNeeded()
    }
    
    func onKeyboardWillHide(curInput: UIView?) {
        guard curInput?.isDescendant(of: self) == true else { return }
        moveToShowupPosition()
    }
    
    func onKeyboardHide(curInput: UIView?) {
        guard curInput?.isDescendant(of: self) == true else { return }
        layoutIfNeeded()
    }
}