#!/usr/bin/env nu

# UpCloud provider utility tests (unit)

# Load mock responses
def load-mock-responses []: nothing -> record {
    let mocks = (open ../../tests/mocks/mock_api_responses.json)
    $mocks
}

# Test framework
def test-result [name: string, passed: bool]: nothing -> record {
    if $passed {
        print $"✓ ($name)"
    } else {
        print $"✗ ($name)"
    }
    {name: $name, passed: $passed}
}

# Test: Parse server UUID
def test_parse_server_uuid []: nothing -> record {
    let result = (do {
        let uuid = "00798b85-efb3-41e9-8e46-10d3f8369f90"
        ($uuid | str length) == 36
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "parse_server_uuid: valid UUID format" $passed
}

# Test: Parse server hostname
def test_parse_server_hostname []: nothing -> record {
    let result = (do {
        let hostname = "test-server-1"
        ($hostname | str contains "test") and ($hostname | str contains "server")
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "parse_server_hostname: hostname parsing" $passed
}

# Test: Extract IP address from interface
def test_extract_ip_address []: nothing -> record {
    let result = (do {
        let ip = "94.237.0.100"
        ($ip | str contains ".") and (($ip | split row "." | length) == 4)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "extract_ip_address: valid IPv4 format" $passed
}

# Test: Validate IP address format
def test_validate_ipv4_format []: nothing -> record {
    let result = (do {
        let ip = "10.255.0.100"
        let parts = ($ip | split row ".")
        ($parts | length) == 4
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_ipv4_format: IPv4 validation" $passed
}

# Test: Zone validation
def test_validate_zone []: nothing -> record {
    let result = (do {
        let zone = "es-mad1"
        ($zone | str contains "-") and (($zone | str length) > 0)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_zone: zone format validation" $passed
}

# Test: Plan validation
def test_validate_plan_name []: nothing -> record {
    let result = (do {
        let plan = "1xCPU-1GB"
        ($plan | str contains "CPU") and ($plan | str contains "GB")
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_plan_name: plan name format" $passed
}

# Test: Storage UUID parsing
def test_parse_storage_uuid []: nothing -> record {
    let result = (do {
        let storage_uuid = "01bb5e25-47f4-45bf-ab01-53754ff16301"
        ($storage_uuid | str length) == 36
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "parse_storage_uuid: storage UUID format" $passed
}

# Test: State value validation
def test_validate_server_state []: nothing -> record {
    let result = (do {
        let states = ["started", "stopped", "maintenance"]
        let state = "started"
        ($state in $states)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_server_state: server state validation" $passed
}

# Test: Network CIDR validation
def test_validate_cidr_block []: nothing -> record {
    let result = (do {
        let cidr = "10.0.0.0/24"
        ($cidr | str contains "/") and (($cidr | split row "/" | length) == 2)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_cidr_block: CIDR format validation" $passed
}

# Test: Storage tier validation
def test_validate_storage_tier []: nothing -> record {
    let result = (do {
        let tiers = ["maxiops", "hdd"]
        let tier = "maxiops"
        ($tier in $tiers)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_storage_tier: storage tier validation" $passed
}

# Test: Temperature/timestamp handling
def test_timestamp_parsing []: nothing -> record {
    let result = (do {
        let ts = (now | into int)
        ($ts > 0)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "timestamp_parsing: timestamp validity" $passed
}

# Test: Price currency validation
def test_validate_price_currency []: nothing -> record {
    let result = (do {
        let currencies = ["EUR", "USD", "GBP"]
        let currency = "EUR"
        ($currency in $currencies)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_price_currency: currency format" $passed
}

# Test: Memory amount validation
def test_validate_memory_amount []: nothing -> record {
    let result = (do {
        let memory = 1024
        ($memory > 0) and (($memory mod 512) == 0)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_memory_amount: memory validation" $passed
}

# Test: CPU count validation
def test_validate_cpu_count []: nothing -> record {
    let result = (do {
        let cores = 2
        ($cores > 0) and ($cores <= 128)
    } | complete)

    let passed = ($result.exit_code == 0 and $result.stdout)
    test-result "validate_cpu_count: CPU count validation" $passed
}

# Main test runner
def main []: nothing -> record {
    print "=== UpCloud Provider Unit Tests (Mock Mode) ==="
    print ""

    let results = [
        (test_parse_server_uuid)
        (test_parse_server_hostname)
        (test_extract_ip_address)
        (test_validate_ipv4_format)
        (test_validate_zone)
        (test_validate_plan_name)
        (test_parse_storage_uuid)
        (test_validate_server_state)
        (test_validate_cidr_block)
        (test_validate_storage_tier)
        (test_timestamp_parsing)
        (test_validate_price_currency)
        (test_validate_memory_amount)
        (test_validate_cpu_count)
    ]

    print ""
    print "Test Summary:"
    print "============="

    let passed = ($results | where {|r| $r.passed} | length)
    let failed = ($results | where {|r| not $r.passed} | length)
    let total = ($results | length)

    print $"Passed: ($passed)/$total"
    print $"Failed: ($failed)/$total"

    {passed: $passed, failed: $failed, total: $total}
}