package com.infendro.cli.command

import com.infendro.cli.parser.*
import com.infendro.cli.parser.Parser

sealed class Argument<T>(
    val parser: Parser<T>,
) {
    abstract val required: Boolean

    class Required<T>(
        parser: Parser<T>,
    ) : Argument<T>(parser) {
        override val required: Boolean
            get() = true
    }

    class OrElse<T>(
        val other: T,
        parser: Parser<T>,
    ) : Argument<T>(parser) {
        override val required: Boolean
            get() = false
    }

    class OrNull<T>(
        parser: Parser<T>,
    ) : Argument<T>(parser) {
        override val required: Boolean
            get() = false
    }

    class Variable<T>(
        parser: Parser<T>,
    ) : Argument<T>(parser) {
        override val required: Boolean
            get() = false
    }

    companion object {
        fun string() =
            Required(StringParser)

        fun stringOrElse(other: String) =
            OrElse(other, StringParser)

        fun stringOrNull() =
            OrNull(StringParser)

        fun strings() =
            Variable(StringParser)

        fun int() =
            Required(IntParser)

        fun intOrElse(other: Int) =
            OrElse(other, IntParser)

        fun intOrNull() =
            OrNull(IntParser)

        fun ints() =
            Variable(IntParser)

        fun boolean() =
            Required(BooleanParser)

        fun booleanOrElse(other: Boolean) =
            OrElse(other, BooleanParser)

        fun booleanOrNull() =
            OrNull(BooleanParser)

        fun booleans() =
            Variable(BooleanParser)

        inline fun <reified T : Enum<T>> enum() =
            Required(enumParser<T>())

        inline fun <reified T : Enum<T>> enumOrElse(other: T) =
            OrElse(other, enumParser<T>())

        inline fun <reified T : Enum<T>> enumOrNull() =
            OrNull(enumParser<T>())

        inline fun <reified T : Enum<T>> enums() =
            Variable(enumParser<T>())
    }
}