import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack(spacing: 20) {
            // 기본 Dynamic Type 적용
            Text("제목입니다")
                .font(.largeTitle)
            
            Text("본문 내용입니다. 이 텍스트는 사용자 설정에 따라 크기가 자동으로 조절됩니다.")
                .font(.body)
            
            // 커스텀 폰트에 Dynamic Type 적용
            Text("커스텀 폰트")
                .font(.custom("HelveticaNeue-Bold", size: 18, relativeTo: .headline))
            
            // 최대/최소 크기 제한
            Text("크기 제한된 텍스트")
                .font(.body)
                .dynamicTypeSize(.medium ... .accessibility3)
        }
        .padding()
    }
}

// 환경값으로 현재 Dynamic Type 크기 감지
struct DynamicTypeAwareView: View {
    @Environment(\.dynamicTypeSize) var dynamicTypeSize
    
    var body: some View {
        VStack {
            if dynamicTypeSize >= .accessibility1 {
                // 접근성 크기일 때 레이아웃 변경
                VStack {
                    Image(systemName: "star")
                    Text("접근성 모드")
                }
            } else {
                // 일반 크기일 때 레이아웃
                HStack {
                    Image(systemName: "star")
                    Text("일반 모드")
                }
            }
        }
    }
}

class DynamicTypeButton: UIButton {
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupButton()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupButton()
    }
    
    private func setupButton() {
        // Dynamic Type 폰트 설정
        titleLabel?.font = UIFont.preferredFont(forTextStyle: .body)
        titleLabel?.adjustsFontForContentSizeCategory = true
        
        // 다중 라인 지원
        titleLabel?.numberOfLines = 0
        titleLabel?.lineBreakMode = .byWordWrapping
        
        // 최소 터치 영역 보장 (44pt)
        NSLayoutConstraint.activate([
            heightAnchor.constraint(greaterThanOrEqualToConstant: 44),
            widthAnchor.constraint(greaterThanOrEqualToConstant: 44)
        ])
        
        // 내용에 맞는 크기 조절
        setContentHuggingPriority(.required, for: .vertical)
        setContentCompressionResistancePriority(.required, for: .vertical)
        
        // 패딩 설정
        contentEdgeInsets = UIEdgeInsets(top: 12, left: 16, bottom: 12, right: 16)
        
        // 폰트 크기 변경 알림 수신
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(contentSizeCategoryDidChange),
            name: UIContentSizeCategory.didChangeNotification,
            object: nil
        )
    }
    
    @objc private func contentSizeCategoryDidChange() {
        // 폰트 크기가 변경되면 레이아웃 업데이트
        titleLabel?.font = UIFont.preferredFont(forTextStyle: .body)
        invalidateIntrinsicContentSize()
        setNeedsLayout()
    }
}

extension UIFont {
    static func customFont(style: TextStyle, weight: Weight = .regular) -> UIFont {
        // 현재 Content Size Category 가져오기
        let contentSize = UIApplication.shared.preferredContentSizeCategory
        
        // 기본 크기 계산
        let baseSize = UIFont.preferredFont(forTextStyle: style).pointSize
        
        // 커스텀 폰트 이름
        let fontName = weight == .bold ? "MyCustomFont-Bold" : "MyCustomFont-Regular"
        
        // 커스텀 폰트 생성
        if let customFont = UIFont(name: fontName, size: baseSize) {
            // Dynamic Type 메트릭스 적용
            return UIFontMetrics(forTextStyle: style).scaledFont(for: customFont)
        }
        
        // 폴백: 시스템 폰트
        return UIFont.preferredFont(forTextStyle: style)
    }
}

// 사용 예시
let titleLabel = UILabel()
titleLabel.font = UIFont.customFont(style: .headline, weight: .bold)
titleLabel.adjustsFontForContentSizeCategory = true

class DynamicImageView: UIImageView {
    private let baseSize: CGSize
    private let textStyle: UIFont.TextStyle
    
    init(baseSize: CGSize, textStyle: UIFont.TextStyle = .body) {
        self.baseSize = baseSize
        self.textStyle = textStyle
        super.init(frame: .zero)
        setupDynamicSizing()
    }
    
    required init?(coder: NSCoder) {
        self.baseSize = CGSize(width: 24, height: 24)
        self.textStyle = .body
        super.init(coder: coder)
        setupDynamicSizing()
    }
    
    private func setupDynamicSizing() {
        updateSize()
        
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(contentSizeCategoryDidChange),
            name: UIContentSizeCategory.didChangeNotification,
            object: nil
        )
    }
    
    @objc private func contentSizeCategoryDidChange() {
        updateSize()
    }
    
    private func updateSize() {
        let fontMetrics = UIFontMetrics(forTextStyle: textStyle)
        let scaledWidth = fontMetrics.scaledValue(for: baseSize.width)
        let scaledHeight = fontMetrics.scaledValue(for: baseSize.height)
        
        NSLayoutConstraint.activate([
            widthAnchor.constraint(equalToConstant: scaledWidth),
            heightAnchor.constraint(equalToConstant: scaledHeight)
        ])
    }
}

// 모든 Content Size Category 테스트
class DynamicTypeTestHelper {
    static let allContentSizes: [UIContentSizeCategory] = [
        .extraSmall, .small, .medium, .large,
        .extraLarge, .extraExtraLarge, .extraExtraExtraLarge,
        .accessibilityMedium, .accessibilityLarge,
        .accessibilityExtraLarge, .accessibilityExtraExtraLarge,
        .accessibilityExtraExtraExtraLarge
    ]
    
    static func testAllSizes(for view: UIView, completion: @escaping (UIContentSizeCategory) -> Void) {
        for contentSize in allContentSizes {
            // Content Size Category 변경
            let traitCollection = UITraitCollection(preferredContentSizeCategory: contentSize)
            view.overrideUserInterfaceStyle = traitCollection.userInterfaceStyle
            
            // 레이아웃 업데이트
            view.setNeedsLayout()
            view.layoutIfNeeded()
            
            // 테스트 실행
            completion(contentSize)
        }
    }
    
    // 스크린샷 자동 생성
    static func captureScreenshots(for viewController: UIViewController) {
        for (index, contentSize) in allContentSizes.enumerated() {
            let traitCollection = UITraitCollection(preferredContentSizeCategory: contentSize)
            viewController.setOverrideTraitCollection(traitCollection, forChild: viewController)
            
            viewController.view.setNeedsLayout()
            viewController.view.layoutIfNeeded()
            
            // 스크린샷 저장
            let screenshot = viewController.view.asImage()
            saveScreenshot(screenshot, name: "DynamicType_\(index)_\(contentSize.rawValue)")
        }
    }
}

extension UIView {
    func asImage() -> UIImage {
        let renderer = UIGraphicsImageRenderer(bounds: bounds)
        return renderer.image { rendererContext in
            layer.render(in: rendererContext.cgContext)
        }
    }
}

import UIKit

class DynamicTypeViewController: UIViewController {
    
    // MARK: - UI Components
    private lazy var scrollView: UIScrollView = {
        let scrollView = UIScrollView()
        scrollView.translatesAutoresizingMaskIntoConstraints = false
        return scrollView
    }()
    
    private lazy var contentStackView: UIStackView = {
        let stackView = UIStackView()
        stackView.axis = .vertical
        stackView.spacing = 20
        stackView.translatesAutoresizingMaskIntoConstraints = false
        return stackView
    }()
    
    private lazy var titleLabel: UILabel = {
        let label = UILabel()
        label.text = "Dynamic Type 예제"
        label.font = UIFont.preferredFont(forTextStyle: .largeTitle)
        label.adjustsFontForContentSizeCategory = true
        label.numberOfLines = 0
        return label
    }()
    
    private lazy var bodyLabel: UILabel = {
        let label = UILabel()
        label.text = "이 텍스트는 사용자의 설정에 따라 크기가 자동으로 조절됩니다. 접근성을 고려한 앱 개발의 좋은 예시입니다."
        label.font = UIFont.preferredFont(forTextStyle: .body)
        label.adjustsFontForContentSizeCategory = true
        label.numberOfLines = 0
        return label
    }()
    
    private lazy var actionButton: UIButton = {
        let button = UIButton(type: .system)
        button.setTitle("동작 버튼", for: .normal)
        button.titleLabel?.font = UIFont.preferredFont(forTextStyle: .headline)
        button.titleLabel?.adjustsFontForContentSizeCategory = true
        button.backgroundColor = .systemBlue
        button.setTitleColor(.white, for: .normal)
        button.layer.cornerRadius = 8
        button.contentEdgeInsets = UIEdgeInsets(top: 12, left: 16, bottom: 12, right: 16)
        return button
    }()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        setupConstraints()
        observeContentSizeChanges()
    }
    
    private func setupUI() {
        view.backgroundColor = .systemBackground
        
        view.addSubview(scrollView)
        scrollView.addSubview(contentStackView)
        
        contentStackView.addArrangedSubview(titleLabel)
        contentStackView.addArrangedSubview(bodyLabel)
        contentStackView.addArrangedSubview(actionButton)
    }
    
    private func setupConstraints() {
        NSLayoutConstraint.activate([
            // ScrollView 제약조건
            scrollView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
            scrollView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
            scrollView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
            scrollView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
            
            // ContentStackView 제약조건
            contentStackView.topAnchor.constraint(equalTo: scrollView.topAnchor, constant: 20),
            contentStackView.leadingAnchor.constraint(equalTo: scrollView.leadingAnchor, constant: 20),
            contentStackView.trailingAnchor.constraint(equalTo: scrollView.trailingAnchor, constant: -20),
            contentStackView.bottomAnchor.constraint(equalTo: scrollView.bottomAnchor, constant: -20),
            contentStackView.widthAnchor.constraint(equalTo: scrollView.widthAnchor, constant: -40),
            
            // 버튼 최소 터치 영역
            actionButton.heightAnchor.constraint(greaterThanOrEqualToConstant: 44)
        ])
    }
    
    private func observeContentSizeChanges() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(contentSizeCategoryDidChange),
            name: UIContentSizeCategory.didChangeNotification,
            object: nil
        )
    }
    
    @objc private func contentSizeCategoryDidChange() {
        // 폰트 업데이트
        titleLabel.font = UIFont.preferredFont(forTextStyle: .largeTitle)
        bodyLabel.font = UIFont.preferredFont(forTextStyle: .body)
        actionButton.titleLabel?.font = UIFont.preferredFont(forTextStyle: .headline)
        
        // 레이아웃 업데이트
        view.setNeedsLayout()
        view.layoutIfNeeded()
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}

// 조건부 레이아웃을 위한 확장
extension DynamicTypeViewController {
    
    private func updateLayoutForContentSize() {
        let currentCategory = UIApplication.shared.preferredContentSizeCategory
        
        // 접근성 크기일 때 레이아웃 변경
        if currentCategory.isAccessibilityCategory {
            contentStackView.spacing = 30
            actionButton.contentEdgeInsets = UIEdgeInsets(top: 16, left: 20, bottom: 16, right: 20)
        } else {
            contentStackView.spacing = 20
            actionButton.contentEdgeInsets = UIEdgeInsets(top: 12, left: 16, bottom: 12, right: 16)
        }
    }
    
    // 커스텀 폰트 스케일링
    private func scaledFont(name: String, textStyle: UIFont.TextStyle) -> UIFont {
        guard let customFont = UIFont(name: name, size: UIFont.preferredFont(forTextStyle: textStyle).pointSize) else {
            return UIFont.preferredFont(forTextStyle: textStyle)
        }
        
        return UIFontMetrics(forTextStyle: textStyle).scaledFont(for: customFont)
    }
}

// Content Size Category 확장
extension UIContentSizeCategory {
    var isAccessibilityCategory: Bool {
        switch self {
        case .accessibilityMedium, .accessibilityLarge, .accessibilityExtraLarge,
             .accessibilityExtraExtraLarge, .accessibilityExtraExtraExtraLarge:
            return true
        default:
            return false
        }
    }
    
    var scaleFactor: CGFloat {
        switch self {
        case .extraSmall: return 0.8
        case .small: return 0.9
        case .medium: return 1.0
        case .large: return 1.0
        case .extraLarge: return 1.1
        case .extraExtraLarge: return 1.2
        case .extraExtraExtraLarge: return 1.3
        case .accessibilityMedium: return 1.4
        case .accessibilityLarge: return 1.5
        case .accessibilityExtraLarge: return 1.6
        case .accessibilityExtraExtraLarge: return 1.7
        case .accessibilityExtraExtraExtraLarge: return 1.8
        default: return 1.0
        }
    }
}

class FontManager {
    static let shared = FontManager()
    private init() {}
    
    private var fontCache: [String: UIFont] = [:]
    private let cacheQueue = DispatchQueue(label: "font.cache.queue", attributes: .concurrent)
    
    func cachedFont(forTextStyle textStyle: UIFont.TextStyle, weight: UIFont.Weight = .regular) -> UIFont {
        let cacheKey = "\(textStyle.rawValue)_\(weight.rawValue)_\(UIApplication.shared.preferredContentSizeCategory.rawValue)"
        
        return cacheQueue.sync {
            if let cachedFont = fontCache[cacheKey] {
                return cachedFont
            }
            
            let font = UIFont.systemFont(ofSize: UIFont.preferredFont(forTextStyle: textStyle).pointSize, weight: weight)
            let scaledFont = UIFontMetrics(forTextStyle: textStyle).scaledFont(for: font)
            
            cacheQueue.async(flags: .barrier) {
                self.fontCache[cacheKey] = scaledFont
            }
            
            return scaledFont
        }
    }
    
    func clearCache() {
        cacheQueue.async(flags: .barrier) {
            self.fontCache.removeAll()
        }
    }
    
    // 메모리 경고 시 캐시 정리
    @objc private func handleMemoryWarning() {
        clearCache()
    }
}

// 배치 업데이트 매니저
class DynamicTypeUpdateManager {
    static let shared = DynamicTypeUpdateManager()
    private init() {}
    
    private var pendingUpdates: Set<weakviewreference> = []
    private var updateTimer: Timer?
    
    func scheduleUpdate(for view: UIView) {
        pendingUpdates.insert(WeakViewReference(view: view))
        
        // 50ms 후에 배치 업데이트 실행
        updateTimer?.invalidate()
        updateTimer = Timer.scheduledTimer(withTimeInterval: 0.05, repeats: false) { _ in
            self.performBatchUpdate()
        }
    }
    
    private func performBatchUpdate() {
        DispatchQueue.main.async {
            for viewRef in self.pendingUpdates {
                viewRef.view?.setNeedsLayout()
            }
            self.pendingUpdates.removeAll()
        }
    }
}

class WeakViewReference: Hashable {
    weak var view: UIView?
    private let identifier = UUID()
    
    init(view: UIView) {
        self.view = view
    }
    
    func hash(into hasher: inout Hasher) {
        hasher.combine(identifier)
    }
    
    static func == (lhs: WeakViewReference, rhs: WeakViewReference) -> Bool {
        return lhs.identifier == rhs.identifier
    }
}
</weakviewreference>

// 문제: Dynamic Type 변경 시 테이블뷰 셀 높이가 제대로 업데이트되지 않음

class DynamicTableViewCell: UITableViewCell {
    @IBOutlet weak var titleLabel: UILabel!
    @IBOutlet weak var bodyLabel: UILabel!
    
    override func awakeFromNib() {
        super.awakeFromNib()
        setupDynamicType()
    }
    
    private func setupDynamicType() {
        titleLabel.font = UIFont.preferredFont(forTextStyle: .headline)
        titleLabel.adjustsFontForContentSizeCategory = true
        
        bodyLabel.font = UIFont.preferredFont(forTextStyle: .body)
        bodyLabel.adjustsFontForContentSizeCategory = true
        
        // 핵심: 셀 높이 자동 계산을 위한 제약조건 설정
        titleLabel.setContentHuggingPriority(.required, for: .vertical)
        titleLabel.setContentCompressionResistancePriority(.required, for: .vertical)
        
        bodyLabel.setContentHuggingPriority(.required, for: .vertical)
        bodyLabel.setContentCompressionResistancePriority(.required, for: .vertical)
    }
}

// 테이블뷰 컨트롤러에서
class DynamicTableViewController: UITableViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 자동 높이 계산 설정
        tableView.estimatedRowHeight = 100
        tableView.rowHeight = UITableView.automaticDimension
        
        // Dynamic Type 변경 감지
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(contentSizeCategoryDidChange),
            name: UIContentSizeCategory.didChangeNotification,
            object: nil
        )
    }
    
    @objc private func contentSizeCategoryDidChange() {
        // 모든 셀의 높이 재계산
        tableView.beginUpdates()
        tableView.endUpdates()
        
        // 또는 더 강력한 방법
        DispatchQueue.main.async {
            self.tableView.reloadData()
        }
    }
}

// 문제: 컬렉션뷰에서 Dynamic Type 변경 시 아이템 크기가 고정되어 있음

class DynamicCollectionViewFlowLayout: UICollectionViewFlowLayout {
    
    override func prepare() {
        super.prepare()
        updateItemSizeForCurrentContentSize()
    }
    
    private func updateItemSizeForCurrentContentSize() {
        guard let collectionView = collectionView else { return }
        
        let contentSize = UIApplication.shared.preferredContentSizeCategory
        let baseWidth = (collectionView.bounds.width - sectionInset.left - sectionInset.right - minimumInteritemSpacing) / 2
        
        // Dynamic Type에 따른 높이 계산
        let scaleFactor = contentSize.scaleFactor
        let baseHeight: CGFloat = 120
        let dynamicHeight = baseHeight * scaleFactor
        
        itemSize = CGSize(width: baseWidth, height: dynamicHeight)
    }
    
    // Content Size Category 변경 시 레이아웃 무효화
    override func shouldInvalidateLayout(forBoundsChange newBounds: CGRect) -> Bool {
        return true
    }
}

class DynamicCollectionViewCell: UICollectionViewCell {
    @IBOutlet weak var titleLabel: UILabel!
    
    override func awakeFromNib() {
        super.awakeFromNib()
        
        titleLabel.font = UIFont.preferredFont(forTextStyle: .subheadline)
        titleLabel.adjustsFontForContentSizeCategory = true
        titleLabel.numberOfLines = 0
        
        // 셀 내용에 맞는 크기 조절
        titleLabel.setContentHuggingPriority(.required, for: .vertical)
    }
    
    override func preferredLayoutAttributesFitting(_ layoutAttributes: UICollectionViewLayoutAttributes) -> UICollectionViewLayoutAttributes {
        let attributes = super.preferredLayoutAttributesFitting(layoutAttributes)
        
        // 내용에 맞는 높이 계산
        let targetSize = CGSize(width: layoutAttributes.frame.width, height: 0)
        let fittingSize = contentView.systemLayoutSizeFitting(
            targetSize,
            withHorizontalFittingPriority: .required,
            verticalFittingPriority: .fittingSizeLevel
        )
        
        attributes.frame.size.height = fittingSize.height
        return attributes
    }
}

// 문제: 커스텀 뷰에서 그린 텍스트가 Dynamic Type에 반응하지 않음

class CustomDrawingView: UIView {
    private var dynamicFont: UIFont {
        return UIFont.preferredFont(forTextStyle: .body)
    }
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupDynamicType()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupDynamicType()
    }
    
    private func setupDynamicType() {
        // Dynamic Type 변경 감지
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(contentSizeCategoryDidChange),
            name: UIContentSizeCategory.didChangeNotification,
            object: nil
        )
    }
    
    @objc private func contentSizeCategoryDidChange() {
        // 다시 그리기
        setNeedsDisplay()
        invalidateIntrinsicContentSize()
    }
    
    override func draw(_ rect: CGRect) {
        super.draw(rect)
        
        guard let context = UIGraphicsGetCurrentContext() else { return }
        
        let text = "커스텀 그리기 텍스트"
        let attributes: [NSAttributedString.Key: Any] = [
            .font: dynamicFont,
            .foregroundColor: UIColor.label
        ]
        
        let attributedString = NSAttributedString(string: text, attributes: attributes)
        let textSize = attributedString.size()
        
        let textRect = CGRect(
            x: (bounds.width - textSize.width) / 2,
            y: (bounds.height - textSize.height) / 2,
            width: textSize.width,
            height: textSize.height
        )
        
        attributedString.draw(in: textRect)
    }
    
    override var intrinsicContentSize: CGSize {
        let text = "커스텀 그리기 텍스트"
        let attributes: [NSAttributedString.Key: Any] = [.font: dynamicFont]
        let size = text.size(withAttributes: attributes)
        return CGSize(width: size.width + 20, height: size.height + 20)
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}