package cli

import (
    "fmt"
    "strconv"
)

type Parser interface {
    Match([]string) ([]string, bool)
    Capture([]string) ([]string, map[string]interface{})
}

type EqualParser struct {
    value string
}

func (self EqualParser) Match(values []string) ([]string, bool) {
    if len(values) == 0 {
        return values, false
    }

    if self.value == values[0] {
        return values[1:], true
    }

    return values, false
}

func (self EqualParser) Capture(values []string) ([]string, map[string]interface{}) {
    remainingValues, _ := self.Match(values)
    return remainingValues, nil
}

func (self EqualParser) String() string {
    return fmt.Sprintf("EqualParser '%s'", self.value)
}


type CaptureGroupParser struct {
    value string
}

func (self CaptureGroupParser) Match(values []string) ([]string, bool) {
    if len(values) == 0 {
        return values, false
    }

    return values[1:], true
}

func (self CaptureGroupParser) key() string {
    return self.value[1:len(self.value) - 1]
}

func (self CaptureGroupParser) Capture(values []string) ([]string, map[string]interface{}) {
    if remainingValues, ok := self.Match(values); ok {
        return remainingValues, map[string]interface{}{self.key(): values[0]}
    }

    return values, nil
}

func (self CaptureGroupParser) String() string {
    return fmt.Sprintf("CaptureGroupParser '%s'", self.value)
}



type BoolFlagParser struct {
    pattern string
    key string
    omitValue bool
    defaultValue bool
}

func (self BoolFlagParser) Match(values []string) ([]string, bool) {
    if self.omitValue {
        return flagKeyMatch(self.pattern, values, 0)
    }

    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
    if !ok {
        return remaining, false
    }

    // Check that value is a valid boolean
    if _, err := strconv.ParseBool(value); err != nil {
        return remaining, false
    }

    return remaining, true
}

func (self BoolFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
    if self.omitValue {
        remaining, ok := flagKeyMatch(self.pattern, values, 0)
        return remaining, map[string]interface{}{self.key: ok}
    }

    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
    if !ok {
        return remaining, map[string]interface{}{self.key: self.defaultValue}
    }

    b, _ := strconv.ParseBool(value)
    return remaining, map[string]interface{}{self.key: b}
}

func (self BoolFlagParser) String() string {
    return fmt.Sprintf("BoolFlagParser '%s'", self.pattern)
}

type StringFlagParser struct {
    pattern string
    key string
    defaultValue string
}

func (self StringFlagParser) Match(values []string) ([]string, bool) {
    remaining, _, ok := flagKeyValueMatch(self.pattern, values, 0)
    return remaining, ok
}

func (self StringFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
    if !ok {
        return remaining, map[string]interface{}{self.key: self.defaultValue}
    }

    return remaining, map[string]interface{}{self.key: value}
}

func (self StringFlagParser) String() string {
    return fmt.Sprintf("StringFlagParser '%s'", self.pattern)
}

type IntFlagParser struct {
    pattern string
    key string
    defaultValue int64
}

func (self IntFlagParser) Match(values []string) ([]string, bool) {
    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
    if !ok {
        return remaining, false
    }

    // Check that value is a valid integer
    if _, err := strconv.ParseInt(value, 10, 64); err != nil {
        return remaining, false
    }

    return remaining, true
}

func (self IntFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
    remaining, value, ok := flagKeyValueMatch(self.pattern, values, 0)
    if !ok {
        return remaining, map[string]interface{}{self.key: self.defaultValue}
    }

    n, _ := strconv.ParseInt(value, 10, 64)
    return remaining, map[string]interface{}{self.key: n}
}

func (self IntFlagParser) String() string {
    return fmt.Sprintf("IntFlagParser '%s'", self.pattern)
}


type StringSliceFlagParser struct {
    pattern string
    key string
    defaultValue []string
}

func (self StringSliceFlagParser) Match(values []string) ([]string, bool) {
    if len(values) < 2 {
        return values, false
    }

    var remainingValues []string

    for i := 0; i < len(values); i++ {
        if values[i] == self.pattern && i + 1 < len(values) {
            i++
            continue
        }
        remainingValues = append(remainingValues, values[i])
    }

    return remainingValues, len(values) != len(remainingValues)
}

func (self StringSliceFlagParser) Capture(values []string) ([]string, map[string]interface{}) {
    remainingValues, ok := self.Match(values)
    if !ok {
        return values, map[string]interface{}{self.key: self.defaultValue}
    }

    var captured []string

    for i := 0; i < len(values); i++ {
        if values[i] == self.pattern && i + 1 < len(values) {
            captured = append(captured, values[i + 1])
        }
    }

    return remainingValues, map[string]interface{}{self.key: captured}
}

func (self StringSliceFlagParser) String() string {
    return fmt.Sprintf("StringSliceFlagParser '%s'", self.pattern)
}


type FlagParser struct {
    parsers []Parser
}

func (self FlagParser) Match(values []string) ([]string, bool) {
    remainingValues := values

    for _, parser := range self.parsers {
        remainingValues, _ = parser.Match(remainingValues)
    }
    return remainingValues, true
}

func (self FlagParser) Capture(values []string) ([]string, map[string]interface{}) {
    captured := map[string]interface{}{}
    remainingValues := values

    for _, parser := range self.parsers {
        var data map[string]interface{}
        remainingValues, data = parser.Capture(remainingValues)
        for key, value := range data {
            captured[key] = value
        }
    }

    return remainingValues, captured
}

func (self FlagParser) String() string {
    return fmt.Sprintf("FlagParser %v", self.parsers)
}


type ShortCircuitParser struct {
    parsers []Parser
}

func (self ShortCircuitParser) Match(values []string) ([]string, bool) {
    remainingValues := values

    for _, parser := range self.parsers {
        var ok bool
        remainingValues, ok = parser.Match(remainingValues)
        if ok {
            return remainingValues, true
        }
    }

    return remainingValues, false
}

func (self ShortCircuitParser) Capture(values []string) ([]string, map[string]interface{}) {
    if len(self.parsers) == 0 {
        return values, nil
    }

    for _, parser := range self.parsers {
        if _, ok := parser.Match(values); ok {
            return parser.Capture(values)
        }
    }

    // No parsers matched at this point,
    // just return the capture value of the first one
    return self.parsers[0].Capture(values)
}

func (self ShortCircuitParser) String() string {
    return fmt.Sprintf("ShortCircuitParser %v", self.parsers)
}

type CompleteParser struct {
    parsers []Parser
}

func (self CompleteParser) Match(values []string) ([]string, bool) {
    remainingValues := copySlice(values)

    for _, parser := range self.parsers {
        var ok bool
        remainingValues, ok = parser.Match(remainingValues)
        if !ok {
            return remainingValues, false
        }
    }

    return remainingValues, len(remainingValues) == 0
}

func (self CompleteParser) Capture(values []string) ([]string, map[string]interface{}) {
    remainingValues := copySlice(values)
    data := map[string]interface{}{}

    for _, parser := range self.parsers {
        var captured map[string]interface{}
        remainingValues, captured = parser.Capture(remainingValues)
        for key, value := range captured {
            data[key] = value
        }
    }

    return remainingValues, data
}

func (self CompleteParser) String() string {
    return fmt.Sprintf("CompleteParser %v", self.parsers)
}

func flagKeyValueMatch(key string, values []string, index int) ([]string, string, bool) {
    if index > len(values) - 2 {
        return values, "", false
    }

    if values[index] == key {
        value := values[index + 1]
        remaining := append(copySlice(values[:index]), values[index + 2:]...)
        return remaining, value, true
    }

    return flagKeyValueMatch(key, values, index + 1)
}

func flagKeyMatch(key string, values []string, index int) ([]string, bool) {
    if index > len(values) - 1 {
        return values, false
    }

    if values[index] == key {
        remaining := append(copySlice(values[:index]), values[index + 1:]...)
        return remaining, true
    }

    return flagKeyMatch(key, values, index + 1)
}

func copySlice(a []string) []string {
    b := make([]string, len(a))
    copy(b, a)
    return b
}