//
//  FontTool.swift
//  
//
//  Created by Thibaut Schmitt on 13/12/2021.
//

import Foundation
import CLIToolCore
import ArgumentParser

/*
 Lire l'infoPlist et check si les fonts dedans sont les memes que celles à générer
 */

//swift run -c release FontToolCore ./SampleFiles/Fonts/sampleFonts.txt --extension-output-path ~/Desktop --extension-name R2Font
struct FontTool: ParsableCommand {
    static let defaultExtensionName = "UIFont"
    
    @Flag(name: .customShort("f"), help: "Should force generation")
    var forceGeneration = false
    
    @Argument(help: "Input files where fonts ared defined.")
    var inputFile: String
    
    @Option(help: "Path where to generate the extension.")
    var extensionOutputPath: String
    
    @Option(help: "Extension name. If not specified, it will generate an UIFont extension")
    var extensionName: String = Self.defaultExtensionName
    
    @Option(help: "Extension suffix. Ex: MyApp, it will generate {extensionName}+ColorsMyApp.swift")
    var extensionSuffix: String = ""
    
    var extensionFileName: String { "\(extensionName)+Font\(extensionSuffix).swift" }
    var extensionFilePath: String { "\(extensionOutputPath)/\(extensionFileName)" }
    
    public func run() throws {
        print("[FontTool] Starting fonts generation")
        
        // Check requirements
        let fileManager = FileManager()
        guard fileManager.fileExists(atPath: inputFile) else {
            let error = FontToolError.fileNotExists(inputFile)
            print(error.localizedDescription)
            FontTool.exit(withError: error)
        }
        
        // Check if needed to regenerate
        guard GeneratorChecker.shouldGenerate(force: forceGeneration, inputFilePath: inputFile, extensionFilePath: extensionFilePath) else {
            print("[FontTool] Fonts are already up to date :) ")
            return
        }
        print("[FontTool] Will generate fonts")
        
        // Get fonts to generate
        let fontsToGenerate = getFontsToGenerate()
        
        let inputFolder = URL(fileURLWithPath: inputFile).deletingLastPathComponent().relativePath
        let fontsFilenames = FontToolHelper
            .getFontsFilenames(fromInputFolder: inputFolder)
            .filter { fontNameWithPath in
                let fontName = URL(fileURLWithPath: fontNameWithPath)
                    .deletingPathExtension()
                    .lastPathComponent
                
                if fontsToGenerate.contains(fontName) {
                    return true
                }
                return false
            }
        
        let fontsFilesnamesWithPath = fontsFilenames.map { "\(inputFolder)/\($0)" }
        let fontsNames = FontToolHelper.getFontsNames(fontsFileNames: fontsFilesnamesWithPath)
        
        // Adding fontsFilenames to header (ex: path/to/font.ttf) to make check of regeneration faster
        let extensionHeader = FontToolContentGenerator.getExtensionHeader(fontsNames: fontsFilenames)
        
        let extensionDefinitionOpening = "extension \(extensionName) {\n"
        let extensionFontsNamesEnum = FontToolContentGenerator.getFontNameEnum(fontsNames: fontsNames)
        let extensionFontsMethods = FontToolContentGenerator.getFontMethods(fontsNames: fontsNames, isUIFontExtension: isUIFontExtension())
        let extensionDefinitionClosing = "}"
        
        generateExtensionFile(extensionHeader,
                              extensionDefinitionOpening,
                              extensionFontsNamesEnum,
                              extensionFontsMethods,
                              extensionDefinitionClosing)
        
        print("Info.plist information:")
        print("\(generatePlistUIAppFonts(fontsNames: fontsNames))")
        
        print("[FontTool] Fonts generated")
    }
    
    private func generateExtensionFile(_ args: String...) {
        // Create file if not exists
        let fileManager = FileManager()
        if fileManager.fileExists(atPath: extensionFilePath) == false {
            Shell.shell("touch", "\(extensionFilePath)")
        }
        
        // Create extension content
        let extensionContent = args.joined(separator: "\n")
        
        // Write content
        let extensionFilePathURL = URL(fileURLWithPath: extensionFilePath)
        try! extensionContent.write(to: extensionFilePathURL, atomically: true, encoding: .utf8)
    }

    private func generatePlistUIAppFonts(fontsNames: [String]) -> String {
        var plistData = "<key>UIAppFonts</key>\n\t<array>\n"
        fontsNames
            .compactMap { $0 }
            .forEach {
                plistData += "\t\t<string>\($0)</string>\n"
            }
        plistData += "\t</array>\n*/"
        
        return plistData
    }
    // MARK: - Helpers
    
    private func getFontsToGenerate() -> [String] {
        let inputFileContent = try! String(contentsOfFile: inputFile, encoding: .utf8)
        return inputFileContent.components(separatedBy: .newlines)
    }
    
    private func isUIFontExtension() -> Bool {
        extensionName == Self.defaultExtensionName
    }
}

FontTool.main()

/*
 
 1. R2Font extension
 swift run -c release FontToolCore ./SampleFiles/Fonts/sampleFonts.txt --extension-output-path ./SampleFiles/Fonts/Generated --extension-name R2Font
 
 1. UIFont defualt extension (will gen static property)
 swift run -c release FontToolCore ./SampleFiles/Fonts/sampleFonts.txt --extension-output-path ./SampleFiles/Fonts/Generated
 
 */