mvm_core_ui/MVMCoreUI/Styles/Styler.swift

//
//  Styler.swift
//  MVMCoreUI
//
//  Created by Kevin Christiano on 4/1/20.
//  Copyright © 2020 Verizon Wireless. All rights reserved.
//

import Foundation


open class Styler {
    //--------------------------------------------------
    // MARK: - Enums
    //--------------------------------------------------
    
    public enum Font: String, Codable {
        case Title2XLarge
        case TitleXLarge
        case BoldTitleLarge
        case RegularTitleLarge
        case BoldTitleMedium
        case RegularTitleMedium
        case BoldBodyLarge
        case RegularBodyLarge
        case BoldBodySmall
        case RegularBodySmall
        case BoldMicro
        case RegularMicro
        
        // Legacy Fonts
        case H1
        case H2
        case H3
        case H32
        case B1
        case B2
        case B3
        case B20
        
        public func pointSize() -> CGFloat {
            switch self {
            case .H1:
                return 40
                
            case .Title2XLarge:
                return 36
                
            case .TitleXLarge,
                 .H32:
                return 32
                
            case .H2:
                return 25
                
            case .BoldTitleLarge,
                 .RegularTitleLarge:
                return 24
                
            case .BoldTitleMedium,
                 .RegularTitleMedium,
                 .B20:
                return 20
                
            case .H3:
                return 18
                
            case .BoldBodyLarge,
                 .RegularBodyLarge:
                return 16
                
            case .BoldBodySmall,
                 .RegularBodySmall,
                 .B1,
                 .B2:
                return 13
                
            case .BoldMicro,
                 .RegularMicro,
                 .B3:
                return 11
            }
        }
        
        public func isBold() -> Bool {
            
            switch self {
            case .Title2XLarge,
                 .TitleXLarge,
                 .RegularTitleLarge,
                 .RegularTitleMedium,
                 .RegularBodyLarge,
                 .RegularBodySmall,
                 .RegularMicro,
                 .B2,
                 .B3,
                 .B20:
                return false
                
            case .BoldTitleLarge,
                 .BoldTitleMedium,
                 .BoldBodyLarge,
                 .BoldBodySmall,
                 .BoldMicro,
                 .H1,
                 .H2,
                 .H3,
                 .H32,
                 .B1:
                return true
            }
        }
        
        public func isLegacyFont() -> Bool {
            
            switch self {
            case .Title2XLarge,
                 .TitleXLarge,
                 .RegularTitleLarge,
                 .RegularTitleMedium,
                 .RegularBodyLarge,
                 .RegularBodySmall,
                 .RegularMicro,
                 .BoldTitleLarge,
                 .BoldTitleMedium,
                 .BoldBodyLarge,
                 .BoldBodySmall,
                 .BoldMicro:
                return false
                
            case .H1,
                 .H2,
                 .H3,
                 .H32,
                 .B1,
                 .B2,
                 .B3,
                 .B20:
                return true
            }
        }
        
        public func getFont(_ genericScaling: Bool = true) -> UIFont? {
            
            let size = genericScaling ? sizeFontGeneric(forCurrentDevice: pointSize()) : pointSize()
            
            if isLegacyFont() {
                switch self {
                case .B2, .B3, .B20:
                    return MFFonts.mfFont55Rg(size)
                    
                default:
                    return MFFonts.mfFont75Bd(size)
                }
            } else {
                if isBold() {
                    return size >= 15 ? MFFonts.mfFontDSBold(size) : MFFonts.mfFontTXBold(size)
                    
                } else {
                    return size >= 15 ? MFFonts.mfFontDSRegular(size) : MFFonts.mfFontTXRegular(size)
                }
            }
        }
        
        public func styleLabel(_ label: UILabel, genericScaling: Bool = true) {
            
            label.font = getFont(genericScaling)
            label.textColor = .black
        }
    }
    
    //--------------------------------------------------
    // MARK: - Functions
    //--------------------------------------------------
    
    open class func sizeObjectGeneric(forCurrentDevice size: CGFloat) -> MFSizeObject? {
        
        let sizeObject = MFSizeObject(standardSize: size, standardiPadPortraitSize: size * 1.3)
        sizeObject?.addLargerThanCustomSize(size * 1.4, forThreshold: MFSizeStandardiPadLandscapeThreshold)
        sizeObject?.addLargerThanCustomSize(size * 1.5, forThreshold: MFSizeiPadProLandscapeThreshold)
        return sizeObject
    }
    
    open class func sizeFontGeneric(forCurrentDevice size: CGFloat) -> CGFloat {
        return sizeObjectGeneric(forCurrentDevice: size)?.getValueBasedOnApplicationWidth() ?? size
    }
    
    //--------------------------------------------------
    // MARK: - Spacing
    //--------------------------------------------------
    
    open class func setDefaultMarginsFor(_ view: UIView?, size: CGFloat, horizontal: Bool = true, vertical: Bool = false) {
        
        let horizontalPadding: CGFloat = horizontal ? Padding.Default.horizontalPadding(forSize: size) : 0
        let verticalPadding: CGFloat = vertical ? PaddingDefaultVerticalSpacing3 : 0
        
        DispatchQueue.main.async {
            MVMCoreUIUtility.setMarginsFor(view, leading: horizontalPadding, top: verticalPadding, trailing: horizontalPadding, bottom: verticalPadding)
        }
    }
    
    open class func setMarginsFor(_ view: UIView?, size: CGFloat, defaultHorizontal horizontal: Bool, top: CGFloat, bottom: CGFloat) {
        
        let horizontalPadding: CGFloat = horizontal ? Padding.Default.horizontalPadding(forSize: size) : 0
        
        DispatchQueue.main.async {
            MVMCoreUIUtility.setMarginsFor(view, leading: horizontalPadding, top: top, trailing: horizontalPadding, bottom: bottom)
        }
    }
}