import CmdArgLib
import CmdArgLibMacros

typealias Greeting = String
typealias Name = String
typealias Count = Int

@main
struct Example_1_Basic {
    
    @MainFunction(shadowGroups: ["lower upper"])
    private static func mf1Basic(
        i includeIndex: Flag,
        u upper: Flag = false,
        l lower: Flag = false,
        c__count repeats: Count? = nil,
        g__greeting greeting: Greeting = "Hello",
        _ name: Name,
        authors: MetaFlag = MetaFlag(string: "Robert Ford and Jesse James"),
        h__help help: MetaFlag = MetaFlag(helpElements: helpElements),
        v__version version: MetaFlag = MetaFlag(string: "version 0.1.0 - 2025-10-14"))
    {
        let count = repeats == nil || repeats! < 1 ? (Int.random(in: 1...3)) : repeats!
        var text = "\(greeting) \(name)"
        text = lower ? text.lowercased() : upper ? text.uppercased() : text
        for index in 1...count {
            var text = (includeIndex ? "\(index) " : "") + "\(greeting) \(name)"
            if upper { text = text.uppercased() }
            print(text)
        }
    }

    private static let helpElements: [ShowElement] = [
        .text("DESCRIPTION:", "Print a greeting."),
        .synopsis("\nUSAGE:"),
        .text("\nPARAMETERS:"),
        .parameter("includeIndex", "Show index of repeated greetings"),
        .parameter("upper", "Print text in upper case"),
        .parameter("lower", "Print text in lower case"),
        .parameter("help", "Show this help message"),
        .parameter("version", "Show version information"),
        .parameter("repeats", "Repeat the greeting $E{repeats} times (the default is a random integer between 1 and 3)" ),
        .parameter("greeting", "The greeting to print"),
        .parameter("name", "Name of person to greet, if any"),
        .text("\nNOTES:\n", note1),
        .text("\n", note2),
    ]

    private static let note1 = """
        The $S{lower} and $S{upper} options shadow each other; only the last one specified 
        is applicable.
        """

    private static let note2 = """
        Bracketed parameters in the synopsis line are not required because they have
        explicit or implied default values. The other parameters are required.
        """
}

import CmdArgLib
import CmdArgLibMacros

enum Mammal: String, CaseIterable, CustomStringConvertible, BasicParameterType { case cat, dog, cow }
enum Reptile: String, CaseIterable, CustomStringConvertible, BasicParameterType { case snake, lizard, turtle }
enum Bird: String, CaseIterable, CustomStringConvertible, BasicParameterType { case dove, robin, eagle }
enum Bug: String, CaseIterable, CustomStringConvertible, BasicParameterType { case bee, ant, ladybug }

extension CaseIterable where AllCases.Element: CustomStringConvertible {
    static var oneOf: String { "A \(Self.casesJoinedWith("or"))" }
}

@main
struct Example_2_Enums {
    @MainFunction
    private static func mf2Enums(
        m__mammal mammal: Mammal = .dog,
        r__reptile maybeReptile: Reptile? = nil,
        b__bird bird: Bird,
        _ bug: Bug,
         h__help help: MetaFlag = MetaFlag(helpElements: helpElements)
    ) {
        let reptile = maybeReptile ?? Reptile.allCases.randomElement()!
        let lines = #taggedValues(mammal, reptile, bird, bug)
        for line in lines { print("  \(line)") }
    }

    private static let helpElements: [ShowElement] = [
        .text("DESCRIPTION:", "Select some animals."),
        .synopsis("\nUSAGE:"),
        .text("\nARGUMENT:"),
        .parameter("bug", Bug.oneOf),
        .text("\nOPTIONS:"),
        .parameter("mammal", Mammal.oneOf),
        .parameter("maybeReptile", "\(Reptile.oneOf) (default: chosen randomly)"),
        .parameter("bird",Bird.oneOf),
        .parameter("help", "Print this help screen"),
    ]
}

import CmdArgLib
import CmdArgLibMacros

enum Mammal: String, CaseIterable, CustomStringConvertible, BasicParameterType {case cat, dog, cow}
enum Reptile: String, CaseIterable, CustomStringConvertible, BasicParameterType {case snake, lizard, turtle}
enum Bug: String, CaseIterable, CustomStringConvertible, BasicParameterType {case bee, ant, ladybug}

extension CaseIterable where AllCases.Element: CustomStringConvertible {
    static var arrayOf:  String {"A \(Self.casesJoinedWith("or")) (can be repeated)"}
    static var listOf:  String {"One or more instances of \(Self.casesJoinedWith("or"))"}
}

@main
struct Example_3_Lists {
    @MainFunction
    private static func mf3Lists(
        r__reptiles reptiles: Variadic<Reptile> = [],
        m__mammal mammals: [Mammal] = [],
        b__bugs bugs: Variadic<Bug>,
        h__help help: MetaFlag = MetaFlag(helpElements: helpElements)
    ) {
        let lines = #taggedValues(mammals, reptiles, bugs)
        for line in lines { print("  \(line)") }
    }

    private static let helpElements: [ShowElement] = [
        .text("DESCRIPTION:", "Select lists of animals."),
        .synopsis("\nUSAGE:"),
        .text("\nPARAMETERS:"),
        .parameter("reptiles", "\(Reptile.listOf)"),
        .parameter("mammals", "\(Mammal.arrayOf)"),
        .parameter("bugs", "\(Bug.listOf)"),
        .parameter("help", "Print this help screen"),
    ]
}

import CmdArgLib
import CmdArgLibMacros
import Foundation

typealias File = String
typealias Factor = Double

@main
struct Example_4_Errors {

    @MainFunction
    private static func mf4Errors(
        w__weightFactor weight: Factor = 1.0,
        _ fileNames: Variadic<File>,
        h__help help: MetaFlag = MetaFlag(helpElements: helpElements)
    ) async throws {
        var errors: [String] = []
        
        // Validate input
        if weight < 0 || weight > 1 { errors.append("The weight must be between 0 and 1.") }
        if fileNames.count > 2 { errors.append("At most two file names can be provided.") }
        
        if errors.isEmpty {
            print("Value of weight:\n   \(weight)")
            for fileName in fileNames {
                try await Task.sleep(nanoseconds: 1_000_000)
                do {
                    let contents = try String(contentsOfFile: fileName, encoding: .utf8).trimmingCharacters(in: .whitespacesAndNewlines)
                    print("Contents of \(fileName):\n   \(contents)")
                }
                catch {
                    // throw error
                    var message = showError(error)
                    if !message.contains(fileName) { message = "Error reading \(fileName): \(message)" }
                    errors.append(message)
                }
            }
        }
        
        if !errors.isEmpty { throw Exception(handledErrors: errors) }
    }

    private static let helpElements: [ShowElement] = [
        .text("DESCRIPTION:", "Print a weight and the contents of some files."),
        .synopsis("\nUSAGE:"),
        .text("\nPARAMETERS:"),
        .parameter("help", "Print this help screen"),
        .parameter("weight", "A weight factor, which must be between 0 and 1"),
        .parameter("fileNames", "One or two files to be processed"),
    ]
}

import CmdArgLib
import CmdArgLibMacros

enum Mammal: String, CaseIterable, CustomStringConvertible, BasicParameterType {case cat, dog, cow}
enum Reptile: String, CaseIterable, CustomStringConvertible, BasicParameterType {case snake, lizard, turtle}
enum Bug: String, CaseIterable, CustomStringConvertible, BasicParameterType {case bee, ant, ladybug}

extension CaseIterable where AllCases.Element: CustomStringConvertible {
    static var oneOf: String { "A \(Self.casesJoinedWith("or"))" }
    static var arrayOf: String {"A \(Self.casesJoinedWith("or")) (can be repeated)"}
    static var listOf: String {"One or more instances of \(Self.casesJoinedWith("or"))"}
}

@main
struct Example_5_Positionals {

    @MainFunction
    private static func mf5Positionals(
        s separator: Flag,
        _ mammal: Mammal,
        _ reptiles: Variadic<Reptile>,
        _ bugs: [Bug],
        h__help help: MetaFlag = MetaFlag(helpElements: helpElements)
    ) {
        let lines = #taggedValues(mammal, reptiles, bugs)
        for line in lines { print("  \(line)") }
    }

    private static let helpElements: [ShowElement] = [
        .text("DESCRIPTION:", "Select a mammal, a list of reptiles and a list of bugs."),
        .synopsis("\nUSAGE:"),
        .text("\nARGUMENTS:"),
        .parameter("mammal", Mammal.oneOf),
        .parameter("reptiles", Reptile.listOf),
        .parameter("bugs", Bug.arrayOf),
        .text("\nFLAGS:"),
        .parameter("separator","Does nothing except terminate a variadic list"),
        .parameter("help", "Print this help screen"),
        .lines("\nNOTE:\n", lines),
    ]

    private static let lines = """
        The first argument must be a mammal.
        This must be followed by one or more reptiles.
        The list of reptiles must be termimanted by "-s".
        The "-s" must be followed by one or more bugs.
        """
}

import CmdArgLib
import CmdArgLibMacros
import Foundation

enum Color: String, CaseIterable, CustomStringConvertible, BasicParameterType {
    case red, blue, yellow
}

enum Animal: String, CaseIterable, CustomStringConvertible, BasicParameterType {
    case cat, dog, cow
}

typealias Greeting = String
typealias Name = String
typealias File = String

@main
struct Example_6_ShowMacros {
    @MainFunction
    private static func mf6ShowMacros(
        g greeting: Greeting = "Hello",
        name maybeName: Name?,
        c__color colors: [Color],
        a__animals animals: Variadic<Animal>,
        h_help_help help: MetaFlag = MetaFlag(helpElements: helpElements)
    ) {
        let name = maybeName ?? "nil"
        let lines = #taggedValues(greeting, name, colors, animals)
        for line in lines { print("  \(line)") }
    }

    private static let helpElements: [ShowElement] = [
        .text("DESCRIPTION:\n", "Print parsed values of command line arguments."),
        .synopsis("\nUSAGE:\n"),
        .text("\nPARAMETERS:"),
        .parameter("greeting", "The greeting to print"),
        .parameter("maybeName", "If specified, the name of the person to greet"),
        .parameter("colors", "Append $E{colors} to the array of colors (can be repeated)"),
        .parameter("animals", "One or more animals (if specified)"),
        .text("\nNOTE:\n", note),
        .lines("\nLABEL MACROS:\n", labelNate),
        .lines("\nTYPE MACROS:\n", typesNote),
    ]

    private static let note = """
        The $E{colors}s are \(Color.casesJoined()), and the $E{animals}s 
        are \(Animal.casesJoined()).
        """

    private static let labelNate = """
        * the shortest label of the "greeting" parameter is "$S{greeting}"
        * the shortest label of the "name" parameter is "$S{maybeName}"
        * the shortest label of the "color" parameter is "$S{colors}"
        * the longest label of the "greeting" parameter is "$L{greeting}"
        * the longest label of the "name" parameter is "$L{maybeName}"
        * the longest label of the "color" parameter is "$L{colors}"
        """

    private static let typesNote = """
      * the type of the "greeting" parameter is "$T{greeting}"
      * the type of the "name" parameter is "$T{maybeName}"
      * the type of the "colors" parameter is "$T{colors}"
      * the type of the "animals" parameter is "$T{animals}"
      * the type of the wrapped element of the "maybeName" parameter is "$E{maybeName}"
      * the type of an element of the "colors" parameter is "$E{colors}" 
      * the type of an element of the "animals" parameter is "$E{animals}"
      """
}

import CmdArgLib
import CmdArgLibMacros
import Foundation

typealias Greeting = String
typealias Name = String
typealias Count = Int

@main
struct Example_7_ManPage {
    
    @MainFunction(shadowGroups: ["lower upper"])
    private static func mf7Man(
        i includeIndex: Flag,
        u upper: Flag,
        l lower: Flag,
        c__count repeats: Count?,
        g__greeting greeting: Greeting = "Hello",
        _ name: Name,
        manpage: MetaFlag = MetaFlag(manPageElements: manPageElements),
        v__version version: MetaFlag = MetaFlag(string: "version 0.1.0 - 2025-10-14"))
    {
        let count = repeats == nil || repeats! < 1 ? (Int.random(in: 1...3)) : repeats!
        var text = "\(greeting) \(name)"
        text = lower ? text.lowercased() : upper ? text.uppercased() : text
        for index in 1...count {
            var text = (includeIndex ? "\(index) " : "") + "\(greeting) \(name)"
            if upper { text = text.uppercased() }
            print(text)
        }
    }

    private static let manPageElements: [ShowElement] = [
        .prologue(description: "print a greeting."),
        .synopsis(),
        .lines("DESCRIPTION", "Print $T{greeting}, followed by $E{name}, $T{repeats} times."),
        .lines("", "The following options are available:"),
        .parameter("greeting", "The greeting to print"),
        .parameter("includeIndex", "Show index of repeated greetings"),
        .parameter("lower", "Print text in lower case"),
        .parameter("repeats", "Repeat the greeting $E{repeats} times (the default is a random integer between 1 and 3)" ),
        .parameter("upper", "Print text in upper case"),
        .parameter("version", "Show version information"),
        .lines("", note1),
        .lines("", note2),
        .lines("", authors),
    ]

     private static let note1 = """
        The $S{lower} and $S{upper} options shadow each other; only the last one specified 
        is applicable.
        """

    private static let note2 = """
        Bracketed parameters in the synopsis line are not required because they have
        explicit or implied default values. The other parameters are required.
        """

    private static let authors = """
        .Sh AUTHORS
        The mf7-man utility was written by
        .%A Robert Ford and Jesse James .
        """
}