package toml

import (

	"fmt"

	"math"

	"strconv"

	"time"

)

func parseInteger(b []byte) (int64, error) {

	if len(b) > 2 && b[0] == '0' {

		switch b[1] {

		case 'x':

			return parseIntHex(b)

		case 'b':

			return parseIntBin(b)

		case 'o':

			return parseIntOct(b)

		default:

			panic(fmt.Errorf("invalid base '%c', should have been checked by scanIntOrFloat", b[1]))

		}

	}

	return parseIntDec(b)

}

func parseLocalDate(b []byte) (LocalDate, error) {

	// full-date      = date-fullyear "-" date-month "-" date-mday

	// date-fullyear  = 4DIGIT

	// date-month     = 2DIGIT  ; 01-12

	// date-mday      = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on month/year

	var date LocalDate

	if len(b) != 10 || b[4] != '-' || b[7] != '-' {

	}

	var err error

	date.Year, err = parseDecimalDigits(b[0:4])

	if err != nil {

		return LocalDate{}, err

	}

	date.Month, err = parseDecimalDigits(b[5:7])

	if err != nil {

		return LocalDate{}, err

	}

	date.Day, err = parseDecimalDigits(b[8:10])

	if err != nil {

		return LocalDate{}, err

	}

	if !isValidDate(date.Year, date.Month, date.Day) {

	}

	return date, nil

}

func parseDecimalDigits(b []byte) (int, error) {

	v := 0

	for i, c := range b {

		if c < '0' || c > '9' {

		}

		v *= 10

		v += int(c - '0')

	}

	return v, nil

}

func parseDateTime(b []byte) (time.Time, error) {

	// offset-date-time = full-date time-delim full-time

	// full-time      = partial-time time-offset

	// time-offset    = "Z" / time-numoffset

	// time-numoffset = ( "+" / "-" ) time-hour ":" time-minute

	dt, b, err := parseLocalDateTime(b)

	if err != nil {

		return time.Time{}, err

	}

	var zone *time.Location

	if len(b) == 0 {

		// parser should have checked that when assigning the date time node

		panic("date time should have a timezone")

	}

	if b[0] == 'Z' || b[0] == 'z' {

		b = b[1:]

		zone = time.UTC

	} else {

		const dateTimeByteLen = 6

		if len(b) != dateTimeByteLen {

		}

		var direction int

		switch b[0] {

		case '-':

			direction = -1

		case '+':

			direction = +1

		default:

		}

		if b[3] != ':' {

		}

		hours, err := parseDecimalDigits(b[1:3])

		if err != nil {

			return time.Time{}, err

		}

		if hours > 23 {

		}

		minutes, err := parseDecimalDigits(b[4:6])

		if err != nil {

			return time.Time{}, err

		}

		if minutes > 59 {

		}

		seconds := direction * (hours*3600 + minutes*60)

		if seconds == 0 {

			zone = time.UTC

		} else {

			zone = time.FixedZone("", seconds)

		}

		b = b[dateTimeByteLen:]

	}

	if len(b) > 0 {

	}

	t := time.Date(

		dt.Year,

		time.Month(dt.Month),

		dt.Day,

		dt.Hour,

		dt.Minute,

		dt.Second,

		dt.Nanosecond,

		zone)

	return t, nil

}

func parseLocalDateTime(b []byte) (LocalDateTime, []byte, error) {

	var dt LocalDateTime

	const localDateTimeByteMinLen = 11

	if len(b) < localDateTimeByteMinLen {

	}

	date, err := parseLocalDate(b[:10])

	if err != nil {

		return dt, nil, err

	}

	dt.LocalDate = date

	sep := b[10]

	if sep != 'T' && sep != ' ' && sep != 't' {

	}

	t, rest, err := parseLocalTime(b[11:])

	if err != nil {

		return dt, nil, err

	}

	dt.LocalTime = t

	return dt, rest, nil

}

// parseLocalTime is a bit different because it also returns the remaining

// []byte that is didn't need. This is to allow parseDateTime to parse those

// remaining bytes as a timezone.

func parseLocalTime(b []byte) (LocalTime, []byte, error) {

	var (

		nspow = [10]int{0, 1e8, 1e7, 1e6, 1e5, 1e4, 1e3, 1e2, 1e1, 1e0}

		t     LocalTime

	)

	// check if b matches to have expected format HH:MM:SS[.NNNNNN]

	const localTimeByteLen = 8

	if len(b) < localTimeByteLen {

	}

	var err error

	t.Hour, err = parseDecimalDigits(b[0:2])

	if err != nil {

		return t, nil, err

	}

	if t.Hour > 23 {

	}

	if b[2] != ':' {

	}

	t.Minute, err = parseDecimalDigits(b[3:5])

	if err != nil {

		return t, nil, err

	}

	if t.Minute > 59 {

	}

	if b[5] != ':' {

	}

	t.Second, err = parseDecimalDigits(b[6:8])

	if err != nil {

		return t, nil, err

	}

	if t.Second > 60 {

	}

	b = b[8:]

	if len(b) >= 1 && b[0] == '.' {

		frac := 0

		precision := 0

		digits := 0

		for i, c := range b[1:] {

			if !isDigit(c) {

				if i == 0 {

				}

				break

			}

			digits++

			const maxFracPrecision = 9

			if i >= maxFracPrecision {

				// go-toml allows decoding fractional seconds

				// beyond the supported precision of 9

				// digits. It truncates the fractional component

				// to the supported precision and ignores the

				// remaining digits.

				//

				// https://github.com/pelletier/go-toml/discussions/707

				continue

			}

			frac *= 10

			frac += int(c - '0')

			precision++

		}

		if precision == 0 {

		}

		t.Nanosecond = frac * nspow[precision]

		t.Precision = precision

		return t, b[1+digits:], nil

	}

	return t, b, nil

}

//nolint:cyclop

func parseFloat(b []byte) (float64, error) {

	if len(b) == 4 && (b[0] == '+' || b[0] == '-') && b[1] == 'n' && b[2] == 'a' && b[3] == 'n' {

		return math.NaN(), nil

	}

	cleaned, err := checkAndRemoveUnderscoresFloats(b)

	if err != nil {

		return 0, err

	}

	if cleaned[0] == '.' {

	}

	if cleaned[len(cleaned)-1] == '.' {

	}

	dotAlreadySeen := false

	for i, c := range cleaned {

		if c == '.' {

			if dotAlreadySeen {

			}

			if !isDigit(cleaned[i-1]) {

			}

			if !isDigit(cleaned[i+1]) {

			}

			dotAlreadySeen = true

		}

	}

	start := 0

	if cleaned[0] == '+' || cleaned[0] == '-' {

		start = 1

	}

	if cleaned[start] == '0' && isDigit(cleaned[start+1]) {

	}

	f, err := strconv.ParseFloat(string(cleaned), 64)

	if err != nil {

	}

	return f, nil

}

func parseIntHex(b []byte) (int64, error) {

	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])

	if err != nil {

		return 0, err

	}

	i, err := strconv.ParseInt(string(cleaned), 16, 64)

	if err != nil {

	}

	return i, nil

}

func parseIntOct(b []byte) (int64, error) {

	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])

	if err != nil {

		return 0, err

	}

	i, err := strconv.ParseInt(string(cleaned), 8, 64)

	if err != nil {

	}

	return i, nil

}

func parseIntBin(b []byte) (int64, error) {

	cleaned, err := checkAndRemoveUnderscoresIntegers(b[2:])

	if err != nil {

		return 0, err

	}

	i, err := strconv.ParseInt(string(cleaned), 2, 64)

	if err != nil {

	}

	return i, nil

}

func isSign(b byte) bool {

	return b == '+' || b == '-'

}

func parseIntDec(b []byte) (int64, error) {

	cleaned, err := checkAndRemoveUnderscoresIntegers(b)

	if err != nil {

		return 0, err

	}

	startIdx := 0

	if isSign(cleaned[0]) {

		startIdx++

	}

	if len(cleaned) > startIdx+1 && cleaned[startIdx] == '0' {

	}