package com.infendro.cli.command

import com.infendro.cli.exception.build.MissingOptionNameException
import com.infendro.cli.parser.*

sealed class Option<T : Any>(
    val parser: Parser<T>,
    val fallback: T?,
    val names: List<String>,
) {
    val flag: Boolean
        get() = fallback != null

    val name: String
        get() = names[0]

    abstract val required: Boolean

    init {
        if (names.isEmpty())
            throw MissingOptionNameException()
    }

    class Required<T : Any>(
        parser: Parser<T>,
        fallback: T?,
        names: List<String>,
    ) : Option<T>(parser, fallback, names) {
        constructor(
            parser: Parser<T>,
            names: List<String>,
        ) : this(parser, null, names)

        override val required: Boolean
            get() = true

        fun orElse(other: T) = OrElse(parser, fallback, names, other)
        fun orNull() = OrNull(parser, fallback, names)
        fun variable() = Variable(parser, fallback, names)
    }

    class OrElse<T : Any>(
        parser: Parser<T>,
        fallback: T?,
        names: List<String>,
        val other: T,
    ) : Option<T>(parser, fallback, names) {
        constructor(
            parser: Parser<T>,
            names: List<String>,
            other: T,
        ) : this(parser, null, names, other)

        override val required: Boolean
            get() = false
    }

    class OrNull<T : Any>(
        parser: Parser<T>,
        fallback: T?,
        names: List<String>,
    ) : Option<T>(parser, fallback, names) {
        constructor(
            parser: Parser<T>,
            names: List<String>,
        ) : this(parser, null, names)

        override val required: Boolean
            get() = false
    }

    class Variable<T : Any>(
        parser: Parser<T>,
        fallback: T?,
        names: List<String>,
    ) : Option<T>(parser, fallback, names) {
        constructor(
            parser: Parser<T>,
            names: List<String>,
        ) : this(parser, null, names)

        override val required: Boolean
            get() = false
    }

    companion object {
        fun string(vararg names: String) =
            Required(StringParser, names.asList())

        fun int(vararg names: String) =
            Required(IntParser, names.asList())

        fun long(vararg names: String) =
            Required(LongParser, names.asList())

        fun float(vararg names: String) =
            Required(FloatParser, names.asList())

        fun double(vararg names: String) =
            Required(DoubleParser, names.asList())

        fun boolean(vararg names: String) =
            Required(BooleanParser, true, names.asList())

        inline fun <reified T : Enum<T>> enum(vararg names: String) =
            Required(enumParser<T>(), names.asList())

        fun regex(vararg names: String) =
            Required(RegexParser, names.asList())
    }
}