// vtest build: !docker-ubuntu-musl && !windows // !windows: fasthttp.Server.run not implemented; !docker-ubuntu-musl: readonly-permission assertions can fail there
import veb
import net.http
import os
import time
import compress.gzip
import compress.zstd

const port = 14013
const port_no_auto = 14014 // Port for static_compression_max_size = 0 test
const port_gzip_only = 14015 // Port for enable_static_gzip only test
const port_zstd_only = 14016 // Port for enable_static_zstd only test
const port_filtered_mimes = 14017 // Port for static_compression_mime_types test

const localserver = 'http://127.0.0.1:${port}'
const localserver_no_auto = 'http://127.0.0.1:${port_no_auto}'
const localserver_gzip_only = 'http://127.0.0.1:${port_gzip_only}'
const localserver_zstd_only = 'http://127.0.0.1:${port_zstd_only}'
const localserver_filtered_mimes = 'http://127.0.0.1:${port_filtered_mimes}'

const exit_after = time.second * 30

const test_file_content = 'This is a test file for gzip compression. It contains enough text to make compression worthwhile. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'
const filtered_css_content = 'body{margin:0;padding:0;color:#123456;background:#fafafa;}'
const filtered_svg_content = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 2 2"><rect width="2" height="2" fill="#fff"/></svg>'

pub struct App {
    veb.StaticHandler
    veb.Middleware[Context]
mut:
    started chan bool
}

pub fn (mut app App) before_accept_loop() {
    app.started <- true
}

pub fn (mut app App) index(mut ctx Context) veb.Result {
    return ctx.text('Hello V!')
}

pub struct Context {
    veb.Context
}

fn sanitize_cache_path_component(component string) string {
    mut sanitized := component.trim_space()
    if sanitized == '' {
        return 'unknown'
    }
    for invalid_char in ['/', '\\', ':', '*', '?', '"', '<', '>', '|'] {
        sanitized = sanitized.replace(invalid_char, '_')
    }
    return sanitized
}

fn static_cache_root_for_tests() string {
    app_dir_name := sanitize_cache_path_component(os.base(os.getwd()))
    return os.join_path(os.cache_dir(), 'veb', 'static_compression', app_dir_name)
}

fn reset_test_static_cache() {
    os.rmdir_all(static_cache_root_for_tests()) or {}
}

fn find_cached_static_file(file_name string, ext string) string {
    cache_root := static_cache_root_for_tests()
    if !os.exists(cache_root) {
        return ''
    }
    for path in os.walk_ext(cache_root, ext) {
        normalized := path.replace('\\', '/')
        if normalized.contains('/${file_name}.') {
            return path
        }
    }
    return ''
}

fn testsuite_begin() {
    os.chdir(os.dir(@FILE))!
    reset_test_static_cache()

    // Create test directory and files
    os.mkdir_all('testdata_compression')!
    os.write_file('testdata_compression/test.txt', test_file_content)!
    os.write_file('testdata_compression/large.txt', test_file_content.repeat(100))!

    // Create readonly directory and file for readonly filesystem test
    os.mkdir_all('testdata_compression/readonly')!
    os.write_file('testdata_compression/readonly/readonly.txt', 'This is a readonly file test')!

    // Create pre-compressed file for manual .gz test
    large_content := 'X'.repeat(2000)
    os.write_file('testdata_compression/precompressed.txt', large_content)!
    compressed_gz := gzip.compress(large_content.bytes()) or { panic(err) }
    os.write_file('testdata_compression/precompressed.txt.gz', compressed_gz.bytestr())!

    // Create pre-compressed file for manual .zst test
    os.write_file('testdata_compression/precompressed_zstd.txt', large_content)!
    compressed_zst := zstd.compress(large_content.bytes()) or { panic(err) }
    os.write_file('testdata_compression/precompressed_zstd.txt.zst', compressed_zst.bytestr())!

    // Create test file for zstd auto-compression
    os.write_file('testdata_compression/zstd_test.txt', test_file_content)!

    // Create file for testing max_size = 0 (no auto-compression)
    os.write_file('testdata_compression/no_auto.txt', 'This file should not be auto-compressed')!

    // Create files for gzip-only and zstd-only tests
    os.write_file('testdata_compression/gzip_only_test.txt', test_file_content)!
    os.write_file('testdata_compression/zstd_only_test.txt', test_file_content)!
    os.write_file('testdata_compression/filtered.css', filtered_css_content)!
    os.write_file('testdata_compression/filtered.svg', filtered_svg_content)!
    filtered_svg_gz := gzip.compress(filtered_svg_content.bytes()) or { panic(err) }
    os.write_file('testdata_compression/filtered.svg.gz', filtered_svg_gz.bytestr())!

    spawn fn () {
        time.sleep(exit_after)
        assert true == false, 'timeout reached!'
        exit(1)
    }()

    run_app_test()
    run_no_auto_compression_test()
    run_gzip_only_test()
    run_zstd_only_test()
    run_filtered_mime_test()
}

fn testsuite_end() {
    // Clean up test files
    os.rmdir_all('testdata_compression') or {}
    reset_test_static_cache()
}

fn run_app_test() {
    mut app := &App{}

    // Enable static compression (zstd/gzip)
    app.enable_static_compression = true
    app.static_compression_max_size = 1048576 // 1MB

    app.handle_static('testdata_compression', true) or { panic(err) }

    // Add compression middleware (gzip for this test app)
    app.use(veb.encode_gzip[Context]())

    spawn veb.run_at[App, Context](mut app, port: port, timeout_in_seconds: 25, family: .ip)
    _ := <-app.started
}

fn run_no_auto_compression_test() {
    mut app := &App{}

    // Enable static compression but disable auto-compression (max_size = 0)
    app.enable_static_compression = true
    app.static_compression_max_size = 0 // Disable auto-compression

    app.handle_static('testdata_compression', true) or { panic(err) }

    // Add compression middleware (gzip for this test app)
    app.use(veb.encode_gzip[Context]())

    spawn veb.run_at[App, Context](mut app,
        port:               port_no_auto
        timeout_in_seconds: 25
        family:             .ip
    )
    _ := <-app.started
}

fn run_gzip_only_test() {
    mut app := &App{}

    // Enable ONLY gzip compression (not zstd, not auto)
    app.enable_static_gzip = true
    app.static_compression_max_size = 1048576 // 1MB

    app.handle_static('testdata_compression', true) or { panic(err) }

    spawn veb.run_at[App, Context](mut app,
        port:               port_gzip_only
        timeout_in_seconds: 25
        family:             .ip
    )
    _ := <-app.started
}

fn run_zstd_only_test() {
    mut app := &App{}

    // Enable ONLY zstd compression (not gzip, not auto)
    app.enable_static_zstd = true
    app.static_compression_max_size = 1048576 // 1MB

    app.handle_static('testdata_compression', true) or { panic(err) }

    spawn veb.run_at[App, Context](mut app,
        port:               port_zstd_only
        timeout_in_seconds: 25
        family:             .ip
    )
    _ := <-app.started
}

fn run_filtered_mime_test() {
    mut app := &App{}

    app.enable_static_compression = true
    app.static_compression_max_size = 1048576
    app.static_compression_mime_types = [veb.mime_types['.css'], veb.mime_types['.js']]

    app.handle_static('testdata_compression', true) or { panic(err) }

    spawn veb.run_at[App, Context](mut app,
        port:               port_filtered_mimes
        timeout_in_seconds: 25
        family:             .ip
    )
    _ := <-app.started
}

fn test_gzip_compression_with_accept_encoding() {
    // Request with Accept-Encoding: gzip
    mut req := http.new_request(.get, '${localserver}/test.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    assert x.header.get(.content_encoding)! == 'gzip'
    assert x.header.get(.vary)! == 'Accept-Encoding'

    // HTTP client auto-decompresses gzip, so verify the content directly
    assert x.body == test_file_content
}

fn test_no_compression_without_accept_encoding() {
    // Request without Accept-Encoding header
    x := http.get('${localserver}/test.txt')!

    assert x.status() == .ok
    // Should not have content-encoding header when client doesn't accept gzip
    _ := x.header.get(.content_encoding) or {
        // Expected: no content-encoding header
        assert x.body == test_file_content
        return
    }
    assert false, 'should not compress without Accept-Encoding: gzip'
}

fn test_gz_file_cache_creation() {
    // First request creates a veb-managed .gz cache file.
    mut req := http.new_request(.get, '${localserver}/test.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    _ := req.do()!

    // Cache files should not be created beside the source file.
    source_gz_path := 'testdata_compression/test.txt.gz'
    assert !os.exists(source_gz_path), '.gz cache file should not be created beside the source file'
    gz_path := find_cached_static_file('test.txt', '.gz')
    assert gz_path != '', '.gz cache file should be created in veb cache dir'

    // Second request should use cached .gz file
    y := req.do()!
    assert y.status() == .ok
    assert y.header.get(.content_encoding)! == 'gzip'

    // Verify Content-Length matches .gz file size (tests os.file_size() code path)
    gz_file_size := os.file_size(gz_path)
    content_length := y.header.get(.content_length)!.u64()
    assert content_length == gz_file_size, 'Content-Length should match .gz file size'
}

fn test_large_file_not_auto_compressed() {
    // Configure app with very small max size to test threshold
    // The large.txt file is ~20KB (200 chars * 100), which exceeds a 1KB threshold
    // But we set it to 1MB, so it should still be compressed
    // Let's test by checking if it gets compressed

    mut req := http.new_request(.get, '${localserver}/large.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    // File should be compressed as it's under 1MB threshold
    assert x.header.get(.content_encoding)! == 'gzip'
}

fn test_already_compressed_flag() {
    // Request a file that will be compressed and cached
    mut req := http.new_request(.get, '${localserver}/test.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    // The file should be compressed only once (in send_file, not by middleware)
    // HTTP client auto-decompresses gzip, so verify the content directly
    assert x.body == test_file_content
}

fn test_readonly_filesystem_fallback() {
    // Test that compression works when source files are in readonly directories.
    // Skip on Windows as readonly permissions work differently (ACL vs chmod)
    $if windows {
        eprintln('Skipping readonly filesystem test on Windows')
        return
    }

    // Make readonly directory readonly (no write permissions)
    readonly_dir := 'testdata_compression/readonly'
    readonly_file := '${readonly_dir}/readonly.txt'

    os.chmod(readonly_dir, 0o555)! // r-xr-xr-x

    mut req := http.new_request(.get, '${localserver}/readonly/readonly.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    // Restore permissions before assertions (for cleanup)
    os.chmod(readonly_dir, 0o755) or {} // rwxr-xr-x

    assert x.status() == .ok
    // Should still be compressed.
    assert x.header.get(.content_encoding)! == 'gzip'

    // Verify that .gz file was NOT created beside the source file.
    gz_path := '${readonly_file}.gz'
    assert !os.exists(gz_path), '.gz cache file should not be created beside readonly source files'

    // HTTP client auto-decompresses gzip, so verify the content directly
    assert x.body == 'This is a readonly file test'
}

fn test_readonly_filesystem_fallback_zstd() {
    // Test that zstd compression works when source files are in readonly directories.
    // Skip on Windows as readonly permissions work differently (ACL vs chmod)
    $if windows {
        eprintln('Skipping readonly filesystem test on Windows')
        return
    }

    // Make readonly directory readonly (no write permissions)
    readonly_dir := 'testdata_compression/readonly'
    readonly_file := '${readonly_dir}/readonly.txt'

    os.chmod(readonly_dir, 0o555)! // r-xr-xr-x

    mut req := http.new_request(.get, '${localserver}/readonly/readonly.txt', '')
    req.add_header(.accept_encoding, 'zstd')
    x := req.do()!

    // Restore permissions before assertions (for cleanup)
    os.chmod(readonly_dir, 0o755) or {} // rwxr-xr-x

    assert x.status() == .ok
    // Should still be compressed.
    assert x.header.get(.content_encoding)! == 'zstd'

    // Verify that .zst file was NOT created beside the source file.
    zst_path := '${readonly_file}.zst'
    assert !os.exists(zst_path), '.zst cache file should not be created beside readonly source files'

    // Verify content is valid zstd
    decompressed := zstd.decompress(x.body.bytes()) or {
        assert false, 'response should be valid zstd even on readonly fs: ${err}'
        return
    }
    assert decompressed.bytestr() == 'This is a readonly file test'
}

fn test_precompressed_gz_file_served() {
    // Test that manually pre-compressed .gz files are always served
    // This validates the manual pre-compression workflow (useful with static_compression_max_size = 0)

    // Request the pre-compressed file
    mut req := http.new_request(.get, '${localserver}/precompressed.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    // Should serve the manually pre-compressed .gz file
    assert x.header.get(.content_encoding)! == 'gzip'
    assert x.header.get(.vary)! == 'Accept-Encoding'

    // HTTP client auto-decompresses gzip, so verify the content directly
    large_content := 'X'.repeat(2000)
    assert x.body == large_content
}

fn test_no_auto_compression_with_max_size_zero() {
    // Test that static_compression_max_size = 0 disables auto-compression
    // but still serves manually pre-compressed .gz files

    // 1. Verify manually pre-compressed .gz files are still served
    mut req1 := http.new_request(.get, '${localserver_no_auto}/precompressed.txt', '')
    req1.add_header(.accept_encoding, 'gzip')
    x := req1.do()!

    assert x.status() == .ok
    // Should serve the manually pre-compressed .gz file
    assert x.header.get(.content_encoding)! == 'gzip'
    assert x.header.get(.vary)! == 'Accept-Encoding'

    // HTTP client auto-decompresses gzip, so verify the content directly
    large_content := 'X'.repeat(2000)
    assert x.body == large_content

    // 2. Verify auto-compression is disabled for files without .gz
    mut req2 := http.new_request(.get, '${localserver_no_auto}/no_auto.txt', '')
    req2.add_header(.accept_encoding, 'gzip')
    y := req2.do()!

    assert y.status() == .ok
    // Should NOT have content-encoding header (no auto-compression)
    _ := y.header.get(.content_encoding) or {
        // Expected: no content-encoding header
        assert y.body == 'This file should not be auto-compressed'
        return
    }
    assert false, 'should not auto-compress with static_compression_max_size = 0'

    // 3. Verify that .gz file was NOT created
    gz_path := 'testdata_compression/no_auto.txt.gz'
    assert !os.exists(gz_path), '.gz cache file should not be created with max_size = 0'
    cache_gz_path := find_cached_static_file('no_auto.txt', '.gz')
    assert cache_gz_path == '', '.gz cache file should not be created in veb cache with max_size = 0'
}

// Zstd tests

fn test_zstd_preferred_over_gzip() {
    // When client supports both zstd and gzip, zstd should be preferred
    mut req := http.new_request(.get, '${localserver}/zstd_test.txt', '')
    req.add_header(.accept_encoding, 'gzip, zstd, br')
    x := req.do()!

    assert x.status() == .ok
    assert x.header.get(.content_encoding)! == 'zstd', 'zstd should be preferred over gzip'
    assert x.header.get(.vary)! == 'Accept-Encoding'

    // Verify the body is valid zstd
    decompressed := zstd.decompress(x.body.bytes()) or {
        assert false, 'failed to decompress zstd response: ${err}'
        return
    }
    assert decompressed.bytestr() == test_file_content
}

fn test_zst_file_cache_creation() {
    // First request should create a veb-managed .zst cache file.
    mut req := http.new_request(.get, '${localserver}/zstd_test.txt', '')
    req.add_header(.accept_encoding, 'zstd')
    _ := req.do()!

    // Cache files should not be created beside the source file.
    source_zst_path := 'testdata_compression/zstd_test.txt.zst'
    assert !os.exists(source_zst_path), '.zst cache file should not be created beside the source file'
    zst_path := find_cached_static_file('zstd_test.txt', '.zst')
    assert zst_path != '', '.zst cache file should be created in veb cache dir'

    // Second request should use cached .zst file
    y := req.do()!
    assert y.status() == .ok
    assert y.header.get(.content_encoding)! == 'zstd'

    // Verify Content-Length matches .zst file size
    zst_file_size := os.file_size(zst_path)
    content_length := y.header.get(.content_length)!.u64()
    assert content_length == zst_file_size, 'Content-Length should match .zst file size'
}

fn test_precompressed_zst_file_served() {
    // Test that manually pre-compressed .zst files are served
    mut req := http.new_request(.get, '${localserver}/precompressed_zstd.txt', '')
    req.add_header(.accept_encoding, 'zstd')
    x := req.do()!

    assert x.status() == .ok
    assert x.header.get(.content_encoding)! == 'zstd'
    assert x.header.get(.vary)! == 'Accept-Encoding'

    // Verify it's the pre-compressed content
    large_content := 'X'.repeat(2000)
    decompressed := zstd.decompress(x.body.bytes()) or {
        assert false, 'manual .zst should be valid: ${err}'
        return
    }
    assert decompressed.bytestr() == large_content
}

fn test_gzip_fallback_when_zstd_not_supported() {
    // When client only supports gzip, gzip should be used
    mut req := http.new_request(.get, '${localserver}/zstd_test.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    assert x.header.get(.content_encoding)! == 'gzip', 'should fallback to gzip when zstd not supported'

    // HTTP client auto-decompresses gzip, so verify the content directly
    assert x.body == test_file_content
}

// Tests for enable_static_gzip only (backward compatibility)

fn test_gzip_only_serves_gzip() {
    // Test that enable_static_gzip alone works (backward compatibility)
    mut req := http.new_request(.get, '${localserver_gzip_only}/gzip_only_test.txt', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    assert x.header.get(.content_encoding)! == 'gzip', 'gzip-only mode should serve gzip'
    assert x.header.get(.vary)! == 'Accept-Encoding'

    // HTTP client auto-decompresses gzip, so verify the content directly
    assert x.body == test_file_content
}

fn test_gzip_only_ignores_zstd_request() {
    // Test that enable_static_gzip does NOT serve zstd even if client supports it
    mut req := http.new_request(.get, '${localserver_gzip_only}/gzip_only_test.txt', '')
    req.add_header(.accept_encoding, 'zstd, gzip')
    x := req.do()!

    assert x.status() == .ok
    // Should serve gzip, NOT zstd (because only enable_static_gzip is set)
    assert x.header.get(.content_encoding)! == 'gzip', 'gzip-only mode should serve gzip even when client supports zstd'

    // HTTP client auto-decompresses gzip, so verify the content directly
    assert x.body == test_file_content
}

fn test_gzip_only_no_compression_without_gzip_header() {
    // Test that enable_static_gzip does not compress when client doesn't accept gzip
    mut req := http.new_request(.get, '${localserver_gzip_only}/gzip_only_test.txt', '')
    req.add_header(.accept_encoding, 'zstd') // Only zstd, no gzip
    x := req.do()!

    assert x.status() == .ok
    // Should not have content-encoding header (no compression)
    _ := x.header.get(.content_encoding) or {
        // Expected: no content-encoding header
        assert x.body == test_file_content
        return
    }
    assert false, 'gzip-only mode should not compress when client only accepts zstd'
}

// Tests for enable_static_zstd only

fn test_zstd_only_serves_zstd() {
    // Test that enable_static_zstd alone works
    mut req := http.new_request(.get, '${localserver_zstd_only}/zstd_only_test.txt', '')
    req.add_header(.accept_encoding, 'zstd')
    x := req.do()!

    assert x.status() == .ok
    assert x.header.get(.content_encoding)! == 'zstd', 'zstd-only mode should serve zstd'
    assert x.header.get(.vary)! == 'Accept-Encoding'

    // Verify the body is valid zstd
    decompressed := zstd.decompress(x.body.bytes()) or {
        assert false, 'failed to decompress zstd response: ${err}'
        return
    }
    assert decompressed.bytestr() == test_file_content
}

fn test_zstd_only_ignores_gzip_request() {
    // Test that enable_static_zstd does not serve gzip even if client supports it
    mut req := http.new_request(.get, '${localserver_zstd_only}/zstd_only_test.txt', '')
    req.add_header(.accept_encoding, 'gzip, zstd')
    x := req.do()!

    assert x.status() == .ok
    // Should serve zstd, not gzip (because only enable_static_zstd is set)
    assert x.header.get(.content_encoding)! == 'zstd', 'zstd-only mode should serve zstd even when client supports gzip'

    decompressed := zstd.decompress(x.body.bytes()) or {
        assert false, 'failed to decompress zstd response: ${err}'
        return
    }
    assert decompressed.bytestr() == test_file_content
}

fn test_zstd_only_no_compression_without_zstd_header() {
    // Test that enable_static_zstd does not compress when client doesn't accept zstd
    mut req := http.new_request(.get, '${localserver_zstd_only}/zstd_only_test.txt', '')
    req.add_header(.accept_encoding, 'gzip') // Only gzip, no zstd
    x := req.do()!

    assert x.status() == .ok
    // Should not have content-encoding header (no compression)
    _ := x.header.get(.content_encoding) or {
        // Expected: no content-encoding header
        assert x.body == test_file_content
        return
    }
    assert false, 'zstd-only mode should not compress when client only accepts gzip'
}

fn test_static_compression_mime_filter_allows_matching_types() {
    mut req := http.new_request(.get, '${localserver_filtered_mimes}/filtered.css', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    assert x.header.get(.content_encoding)! == 'gzip'
    assert x.header.get(.vary)! == 'Accept-Encoding'
    assert x.body == filtered_css_content

    gz_path := find_cached_static_file('filtered.css', '.gz')
    assert gz_path != '', 'allowed MIME type should create a cached compressed file'
}

fn test_static_compression_mime_filter_skips_excluded_types() {
    mut req := http.new_request(.get, '${localserver_filtered_mimes}/filtered.svg', '')
    req.add_header(.accept_encoding, 'gzip')
    x := req.do()!

    assert x.status() == .ok
    _ := x.header.get(.content_encoding) or {
        assert x.body == filtered_svg_content
        return
    }
    assert false, 'excluded MIME type should not be served from compressed content'
}