module cbor

// Typed errors for CBOR decode failures. Pattern-match in callers:
//
//   cbor.decode[User](bad) or {
//       if err is cbor.UnexpectedEofError { ... }
//   }

// UnexpectedEofError fires when the decoder runs past the end of its input.
// `need` is i64 so it can represent the full CBOR length range (which is
// u64 on the wire); huge values are clamped to i64::max for reporting.
pub struct UnexpectedEofError {
    Error
pub:
    pos       int // position at which the read began
    need      i64 // bytes the decoder was trying to read
    remaining int // bytes actually available
}

// msg formats an UnexpectedEofError for `IError.msg()`.
pub fn (e &UnexpectedEofError) msg() string {
    if e.need == max_i64 {
        return 'cbor: unexpected EOF at pos ${e.pos}: declared length exceeds available input (have ${e.remaining})'
    }
    return 'cbor: unexpected EOF at pos ${e.pos}: need ${e.need} bytes, have ${e.remaining}'
}

// MalformedError fires when the byte stream violates RFC 8949 well-formedness.
pub struct MalformedError {
    Error
pub:
    pos    int
    reason string
}

// msg formats a MalformedError for `IError.msg()`.
pub fn (e &MalformedError) msg() string {
    return 'cbor: malformed at pos ${e.pos}: ${e.reason}'
}

// TypeMismatchError fires when a typed read finds a different major type.
pub struct TypeMismatchError {
    Error
pub:
    pos      int
    expected string
    got      u8 // initial byte
}

// msg formats a TypeMismatchError for `IError.msg()`.
pub fn (e &TypeMismatchError) msg() string {
    return 'cbor: type mismatch at pos ${e.pos}: expected ${e.expected}, got initial byte 0x${e.got:02x}'
}

// MaxDepthError fires when nested arrays/maps exceed the configured cap.
pub struct MaxDepthError {
    Error
pub:
    pos       int
    max_depth int
}

// msg formats a MaxDepthError for `IError.msg()`.
pub fn (e &MaxDepthError) msg() string {
    return 'cbor: max nesting depth ${e.max_depth} exceeded at pos ${e.pos}'
}

// UnknownFieldError fires when a struct decoded with `deny_unknown_fields`
// encounters an unmapped key.
pub struct UnknownFieldError {
    Error
pub:
    pos  int
    name string
}

// msg formats an UnknownFieldError for `IError.msg()`.
pub fn (e &UnknownFieldError) msg() string {
    return 'cbor: unknown field "${e.name}" at pos ${e.pos}'
}

// IntRangeError fires when a decoded integer doesn't fit the target type.
pub struct IntRangeError {
    Error
pub:
    pos    int
    target string
    value  string
}

// msg formats an IntRangeError for `IError.msg()`.
pub fn (e &IntRangeError) msg() string {
    return 'cbor: integer ${e.value} at pos ${e.pos} out of range for ${e.target}'
}

// InvalidUtf8Error fires when a text-string payload isn't valid UTF-8 and
// the decoder is configured to validate strings.
pub struct InvalidUtf8Error {
    Error
pub:
    pos int
}

// msg formats an InvalidUtf8Error for `IError.msg()`.
pub fn (e &InvalidUtf8Error) msg() string {
    return 'cbor: invalid UTF-8 in text string at pos ${e.pos}'
}

@[cold; inline]
fn eof_at(pos int) IError {
    return UnexpectedEofError{
        pos:       pos
        need:      1
        remaining: 0
    }
}

@[cold; inline]
fn eof_needing(pos int, need i64, remaining int) IError {
    return UnexpectedEofError{
        pos:       pos
        need:      need
        remaining: remaining
    }
}

// eof_oversized reports an EOF caused by a length argument larger than
// the host can represent, clamped to i64::max so callers see a sensible
// number rather than a negative wrap-around. Used by string/bytes
// chunk readers where the wire length is u64.
@[cold; inline]
fn eof_oversized(pos int, want u64, remaining int) IError {
    clamped := if want > u64(max_i64) { max_i64 } else { i64(want) }
    return UnexpectedEofError{
        pos:       pos
        need:      clamped
        remaining: remaining
    }
}

@[cold; inline]
fn malformed(pos int, reason string) IError {
    return MalformedError{
        pos:    pos
        reason: reason
    }
}

@[cold; inline]
fn type_mismatch(pos int, expected string, got u8) IError {
    return TypeMismatchError{
        pos:      pos
        expected: expected
        got:      got
    }
}

@[cold; inline]
fn int_range(pos int, target string, value string) IError {
    return IntRangeError{
        pos:    pos
        target: target
        value:  value
    }
}