//
//  Typogprahy+Styles.swift
//  VDS
//
//  Created by Matt Bruce on 7/21/23.
//

import Foundation
import UIKit
import VDSCoreTokens

//MARK: Definitions
extension TextStyle {
    internal enum Style: String, CaseIterable {
        case boldFeatureXLarge
            case featureXLarge
            case boldFeatureLarge
            case featureLarge
            case boldFeatureMedium
            case featureMedium
            case boldFeatureSmall
            case featureSmall
            case boldFeatureXSmall
            case featureXSmall
            case boldTitle2XLarge
            case title2XLarge
            case boldTitleXLarge
            case titleXLarge
            case boldTitleLarge
            case titleLarge
            case boldTitleMedium
            case titleMedium
            case boldTitleSmall
            case titleSmall
            case boldBodyLarge
            case bodyLarge
            case boldBodyMedium
            case bodyMedium
            case boldBodySmall
            case bodySmall
            case boldMicro
            case micro
    }
    
    // Static properties for different text styles    
    public static var boldFeatureXLarge: TextStyle { Provider.style(for: .boldFeatureXLarge) }
    public static var featureXLarge: TextStyle { Provider.style(for: .featureXLarge) }
    public static var boldFeatureLarge: TextStyle { Provider.style(for: .boldFeatureLarge) }
    public static var featureLarge: TextStyle { Provider.style(for: .featureLarge) }
    public static var boldFeatureMedium: TextStyle { Provider.style(for: .boldFeatureMedium) }
    public static var featureMedium: TextStyle { Provider.style(for: .featureMedium) }
    public static var boldFeatureSmall: TextStyle { Provider.style(for: .boldFeatureSmall) }
    public static var featureSmall: TextStyle { Provider.style(for: .featureSmall) }
    public static var boldFeatureXSmall: TextStyle { Provider.style(for: .boldFeatureXSmall) }
    public static var featureXSmall: TextStyle { Provider.style(for: .featureXSmall) }
    public static var boldTitle2XLarge: TextStyle { Provider.style(for: .boldTitle2XLarge) }
    public static var title2XLarge: TextStyle { Provider.style(for: .title2XLarge) }
    public static var boldTitleXLarge: TextStyle { Provider.style(for: .boldTitleXLarge) }
    public static var titleXLarge: TextStyle { Provider.style(for: .titleXLarge) }
    public static var boldTitleLarge: TextStyle { Provider.style(for: .boldTitleLarge) }
    public static var titleLarge: TextStyle { Provider.style(for: .titleLarge) }
    public static var boldTitleMedium: TextStyle { Provider.style(for: .boldTitleMedium) }
    public static var titleMedium: TextStyle { Provider.style(for: .titleMedium) }
    public static var boldTitleSmall: TextStyle { Provider.style(for: .boldTitleSmall) }
    public static var titleSmall: TextStyle { Provider.style(for: .titleSmall) }
    public static var boldBodyLarge: TextStyle { Provider.style(for: .boldBodyLarge) }
    public static var bodyLarge: TextStyle { Provider.style(for: .bodyLarge) }
    public static var boldBodyMedium: TextStyle { Provider.style(for: .boldBodyMedium) }
    public static var bodyMedium: TextStyle { Provider.style(for: .bodyMedium) }
    public static var boldBodySmall: TextStyle { Provider.style(for: .boldBodySmall) }
    public static var bodySmall: TextStyle { Provider.style(for: .bodySmall) }
    public static var boldMicro: TextStyle {  Provider.style(for: .boldMicro) }
    public static var micro: TextStyle { Provider.style(for: .micro) }
    
    public static var allCases: [TextStyle] { Style.allCases.compactMap { Provider.style(for: $0) } }
    
    public static func convert(font: UIFont) -> TextStyle {
        guard let found = allCases.first(where: { font.fontName == $0.fontFace.fontName && font.pointSize == $0.pointSize} ) else {
            return TextStyle(rawValue: "Custom\(font.fontName)", fontFace: .custom(font), pointSize: font.pointSize)
        }
        return found
    }
}

extension TextStyle {
    /// Enum used to describe the naming convention for the Typography.
    public enum StandardStyle: String, CaseIterable {
        case featureXLarge,
             featureLarge,
             featureMedium,
             featureSmall,
             featureXSmall,
             title2XLarge,
             titleXLarge,
             titleLarge,
             titleMedium,
             titleSmall,
             bodyLarge,
             bodyMedium,
             bodySmall,
             micro
        
        /// The bold version for this Standard Style.
        public var bold: TextStyle {
            return TextStyle(rawValue: "bold\(rawValue.prefix(1).uppercased())\(rawValue.dropFirst())")!
        }
        
        /// The regular version for this Standard Style.
        public var regular: TextStyle {
            TextStyle(rawValue: rawValue)!
        }
    }
    
    /// The converting a TextStyle to a StandardStyle.
    public func toStandardStyle() -> StandardStyle {
        var rawName = rawValue
        if rawName.hasPrefix("bold") {
            let updatedRaw = rawName.replacingOccurrences(of: "bold", with: "")
            rawName = updatedRaw.prefix(1).lowercased() + updatedRaw.dropFirst()
        }
        return StandardStyle(rawValue: rawName)!
    }
}