module pg

import orm
import time

// These tests exercise the PostgreSQL TIMESTAMP/TIMESTAMPTZ text decoder
// directly, so they do not require a running PostgreSQL server.

fn test_plain_timestamp() {
    t := pg_parse_timestamp('2024-01-15 14:00:00')!
    assert t.year == 2024
    assert t.month == 1
    assert t.day == 15
    assert t.hour == 14
    assert t.minute == 0
    assert t.second == 0
    assert t.nanosecond == 0
}

fn test_fractional_seconds_microsecond_precision() {
    t := pg_parse_timestamp('2024-01-15 14:00:00.123456')!
    assert t.hour == 14
    assert t.second == 0
    // 123456 microseconds preserved as nanoseconds
    assert t.nanosecond == 123456000
}

fn test_timestamptz_utc_offset() {
    // `+00` offset -> already UTC, value unchanged.
    t := pg_parse_timestamp('2024-01-15 13:00:00.123456+00')!
    assert t.year == 2024
    assert t.month == 1
    assert t.day == 15
    assert t.hour == 13
    assert t.minute == 0
    assert t.second == 0
    assert t.nanosecond == 123456000
}

fn test_timestamptz_positive_offset_normalized_to_utc() {
    // 14:00 at +01:00 -> 13:00 UTC
    t := pg_parse_timestamp('2024-01-15 14:00:00.123456+01:00')!
    assert t.hour == 13
    assert t.minute == 0
    assert t.nanosecond == 123456000
}

fn test_timestamptz_positive_short_offset() {
    // 14:00 at +02 -> 12:00 UTC
    t := pg_parse_timestamp('2024-01-15 14:00:00+02')!
    assert t.hour == 12
    assert t.minute == 0
}

fn test_timestamptz_offset_with_minutes() {
    // 14:00 at +02:30 -> 11:30 UTC
    t := pg_parse_timestamp('2024-01-15 14:00:00+02:30')!
    assert t.hour == 11
    assert t.minute == 30
}

fn test_timestamptz_negative_offset_normalized_to_utc() {
    // 14:00 at -05:00 -> 19:00 UTC
    t := pg_parse_timestamp('2024-01-15 14:00:00-05')!
    assert t.hour == 19
    assert t.minute == 0
}

fn test_timestamptz_negative_offset_with_minutes_day_rollover() {
    // 23:00 at -05:30 -> 04:30 UTC next day
    t := pg_parse_timestamp('2024-01-15 23:00:00-05:30')!
    assert t.day == 16
    assert t.hour == 4
    assert t.minute == 30
}

fn test_timestamptz_z_suffix() {
    t := pg_parse_timestamp('2024-01-15 14:00:00.5Z')!
    assert t.hour == 14
    assert t.nanosecond == 500000000
}

fn test_infinity_returns_clear_error() {
    pg_parse_timestamp('infinity') or {
        assert err.msg().contains('infinity')
        return
    }
    assert false, 'expected an error for the special value `infinity`'
}

fn test_negative_infinity_returns_clear_error() {
    pg_parse_timestamp('-infinity') or {
        assert err.msg().contains('infinity')
        return
    }
    assert false, 'expected an error for the special value `-infinity`'
}

fn test_bc_suffix_returns_clear_error() {
    pg_parse_timestamp('0001-01-01 00:00:00 BC') or {
        assert err.msg().contains('BC')
        return
    }
    assert false, 'expected an error for a BC timestamp value'
}

fn test_bc_suffix_with_offset_returns_clear_error() {
    pg_parse_timestamp('0044-03-15 12:00:00+00 BC') or {
        assert err.msg().contains('BC')
        return
    }
    assert false, 'expected an error for a BC TIMESTAMPTZ value'
}

fn test_garbage_seconds_suffix_is_rejected() {
    // `string.int()` would silently keep the `00` prefix; strict parsing must reject it.
    pg_parse_timestamp('2024-01-15 14:00:00 XY') or { return }
    assert false, 'expected an error for a trailing non-numeric suffix'
}

fn test_unix_timestamp_path_decodes_integer() {
    // Mirror the ORM fallback: a bare integer string is a Unix timestamp.
    p := val_to_primitive('1700000000', orm.time_)!
    t := p as time.Time
    assert t.unix() == 1700000000
}

fn test_infinity_via_val_to_primitive_errors() {
    // `infinity` has no date/time punctuation; it must still reach the parser and
    // error instead of decoding to the Unix epoch.
    val_to_primitive('infinity', orm.time_) or {
        assert err.msg().contains('infinity')
        return
    }
    assert false, 'expected an error decoding `infinity` via val_to_primitive'
}

fn test_year_out_of_range_returns_error_not_panic() {
    // PostgreSQL accepts years past 9999, which `time.new` cannot represent. The
    // decoder must return an error rather than panicking.
    pg_parse_timestamp('10000-01-01 00:00:00') or {
        assert err.msg().contains('out of range')
        return
    }
    assert false, "expected an error for a year beyond V's supported range"
}

fn test_out_of_range_via_val_to_primitive_errors() {
    val_to_primitive('10000-01-01 00:00:00', orm.time_) or {
        assert err.msg().contains('out of range')
        return
    }
    assert false, 'expected an error decoding an out-of-range timestamp'
}

fn test_offset_pushes_year_out_of_range_returns_error() {
    // A valid local timestamp that normalizes to year 10000 in UTC must still error,
    // not silently bypass the range guard via the offset shift.
    pg_parse_timestamp('9999-12-31 23:30:00-01') or {
        assert err.msg().contains('out of range')
        return
    }
    assert false, 'expected an error when the UTC offset pushes the year out of range'
}

fn test_offset_within_range_still_decodes() {
    // A near-boundary value that stays in range after normalization must succeed.
    t := pg_parse_timestamp('9999-12-31 22:30:00-01')!
    assert t.year == 9999
    assert t.month == 12
    assert t.day == 31
    assert t.hour == 23
    assert t.minute == 30
}

fn test_offset_normalizes_into_bc_returns_error() {
    // `0001-01-01 00:30:00+01` normalizes to `0000-12-31 23:30:00` (year 0 == 1 BC),
    // which is unrepresentable and must be rejected rather than silently accepted.
    pg_parse_timestamp('0001-01-01 00:30:00+01') or {
        assert err.msg().contains('BC')
        return
    }
    assert false, 'expected an error when the UTC offset normalizes into a BC/year-0 date'
}

fn test_lower_boundary_offset_within_range_still_decodes() {
    // `0001-01-01 01:30:00+01` normalizes to `0001-01-01 00:30:00` (year 1), still valid.
    t := pg_parse_timestamp('0001-01-01 01:30:00+01')!
    assert t.year == 1
    assert t.month == 1
    assert t.day == 1
    assert t.hour == 0
    assert t.minute == 30
}

fn test_year_zero_literal_returns_bc_error() {
    // A direct year-0 value (no ` BC` suffix) is still unrepresentable.
    pg_parse_timestamp('0000-01-01 00:00:00') or {
        assert err.msg().contains('BC')
        return
    }
    assert false, 'expected a BC/year-0 error for a literal year-0 timestamp'
}

fn test_issue_27556_example() {
    // The exact value from the issue: stored as '2024-01-15 14:00:00.123456+01:00'
    // with the session in UTC, PostgreSQL returns it as below.
    t := pg_parse_timestamp('2024-01-15 13:00:00.123456+00')!
    expected := time.new(
        year:       2024
        month:      1
        day:        15
        hour:       13
        minute:     0
        second:     0
        nanosecond: 123456000
        is_local:   false
    )
    assert t.unix() == expected.unix()
    assert t.nanosecond == expected.nanosecond
}