// vtest build: !windows // fasthttp.Server.run is not implemented on windows yet
import veb
import net.http
import os
import time
import compress.gzip
import compress.zstd

const port = 13001

const localserver = 'http://127.0.0.1:${port}'

const exit_after = time.second * 10

pub struct Context {
    veb.Context
pub mut:
    counter              int
    bound_middleware_tag string
}

@[heap]
pub struct App {
    veb.Middleware[Context]
mut:
    started                chan bool
    bound_middleware_hits  int
    bound_middleware_value string
}

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

pub fn (app &App) index(mut ctx Context) veb.Result {
    return ctx.text('from index, ${ctx.counter}')
}

@['/bar/bar']
pub fn (app &App) bar(mut ctx Context) veb.Result {
    return ctx.text('from bar, ${ctx.counter}')
}

pub fn (app &App) unreachable(mut ctx Context) veb.Result {
    return ctx.text('should never be reachable!')
}

@['/nested/route/method']
pub fn (app &App) nested(mut ctx Context) veb.Result {
    return ctx.text('from nested, ${ctx.counter}')
}

pub fn (app &App) after(mut ctx Context) veb.Result {
    return ctx.text('from after, ${ctx.counter}')
}

@['/admin/auth'; get]
pub fn (app &App) admin_auth_get(mut ctx Context) veb.Result {
    return ctx.text('protected get route')
}

@['/admin/auth'; post]
pub fn (app &App) admin_auth_post(mut ctx Context) veb.Result {
    return ctx.text('public post route')
}

@['/gzip']
pub fn (app &App) gzip_test(mut ctx Context) veb.Result {
    return ctx.text('gzip response, ${ctx.counter}')
}

@['/decode_gzip'; post]
pub fn (app &App) decode_gzip_test(mut ctx Context) veb.Result {
    return ctx.text('received: ${ctx.req.data}')
}

@['/zstd']
pub fn (app &App) zstd_test(mut ctx Context) veb.Result {
    return ctx.text('zstd response, ${ctx.counter}')
}

@['/decode_zstd'; post]
pub fn (app &App) decode_zstd_test(mut ctx Context) veb.Result {
    return ctx.text('received: ${ctx.req.data}')
}

@['/content']
pub fn (app &App) content_test(mut ctx Context) veb.Result {
    return ctx.text('content response, ${ctx.counter}')
}

// Test route for double-send regression test
@['/double_after']
pub fn (app &App) double_after(mut ctx Context) veb.Result {
    return ctx.text('handler response')
}

// bound verifies that route middleware can read app state before the handler runs.
@['/bound']
pub fn (app &App) bound(mut ctx Context) veb.Result {
    return ctx.text('${app.bound_middleware_value}, ${app.bound_middleware_hits}, ${ctx.bound_middleware_tag}, ${ctx.counter}')
}

pub fn (app &App) app_middleware(mut ctx Context) bool {
    ctx.counter++
    return true
}

pub fn (app &App) before_request(mut ctx Context) bool {
    ctx.res.header.add_custom('X-BEFORE-REQUEST-MIDDLEWARE', 'true') or { panic(err) }
    return true
}

// route_bound_middleware reads and mutates the bound app to exercise stateful middleware.
pub fn (mut app App) route_bound_middleware(mut ctx Context) bool {
    app.bound_middleware_hits++
    ctx.bound_middleware_tag = app.bound_middleware_value
    ctx.counter += 10
    return true
}

fn middleware_handler(mut ctx Context) bool {
    ctx.counter++
    return true
}

fn middleware_unreachable(mut ctx Context) bool {
    ctx.text('unreachable, ${ctx.counter}')
    return false
}

fn after_middleware(mut ctx Context) bool {
    ctx.counter++
    ctx.res.header.add_custom('X-AFTER', ctx.counter.str()) or { panic('bad') }
    return true
}

fn auth_required_middleware(mut ctx Context) bool {
    ctx.res.set_status(.unauthorized)
    ctx.text('auth required')
    return false
}

// Global after-middleware that sends a response (for double-send regression test)
// Only sends for /double_after route to avoid breaking other tests
fn global_after_sends_response(mut ctx Context) bool {
    if ctx.req.url.starts_with('/double_after') {
        ctx.text('global after response')
    }
    return true
}

// Route after-middleware that also tries to send (should be skipped if global already sent)
fn route_after_sends_response(mut ctx Context) bool {
    // Add header to prove this middleware ran (for regression test)
    ctx.res.header.add_custom('X-ROUTE-AFTER-RAN', 'true') or {}
    ctx.text('route after response - should not appear')
    return true
}

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

    mut app := &App{
        bound_middleware_value: 'from app middleware'
    }
    // even though `route_use` is called first, global middleware is still executed first
    app.Middleware.route_use('/unreachable', handler: middleware_unreachable)

    // global middleware
    app.Middleware.use(handler: middleware_handler)
    app.Middleware.use(handler: app.app_middleware)
    app.Middleware.use(handler: app.before_request)

    // should match only one slash
    app.Middleware.route_use('/bar/:foo', handler: middleware_handler)
    // should match multiple slashes
    app.Middleware.route_use('/nested/:path...', handler: middleware_handler)
    app.Middleware.route_use('/bound', handler: app.route_bound_middleware)

    app.Middleware.route_use('/after', handler: after_middleware, after: true)
    app.Middleware.route_use('/admin/auth',
        handler: auth_required_middleware
        methods: [
            .get,
        ]
    )

    // Gzip middleware tests
    app.Middleware.use(veb.decode_gzip[Context]())
    app.Middleware.route_use('/gzip', veb.encode_gzip[Context]())

    // Zstd middleware tests
    app.Middleware.use(veb.decode_zstd[Context]())
    app.Middleware.route_use('/zstd', veb.encode_zstd[Context]())

    // Auto content encoding middleware (zstd/gzip based on Accept-Encoding)
    app.Middleware.route_use('/content', veb.encode_auto[Context]())

    // Regression test: global after-middleware sends response, route after-middleware should be skipped
    app.Middleware.use(handler: global_after_sends_response, after: true)
    app.Middleware.route_use('/double_after', handler: route_after_sends_response, after: true)

    spawn veb.run_at[App, Context](mut app, port: port, timeout_in_seconds: 2, family: .ip)
    // app startup time
    _ := <-app.started

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

fn test_index() {
    x := http.get(localserver)!
    assert x.body == 'from index, 2'
}

fn test_bound_before_request_named_middleware_does_not_timeout() {
    x := http.fetch(http.FetchConfig{
        url:           localserver
        read_timeout:  1500 * time.millisecond
        write_timeout: 1500 * time.millisecond
    })!
    assert x.body == 'from index, 2'
    assert x.header.get_custom('X-BEFORE-REQUEST-MIDDLEWARE')! == 'true'
}

fn test_unreachable_order() {
    x := http.get('${localserver}/unreachable')!
    assert x.body == 'unreachable, 2'
}

fn test_dynamic_route() {
    x := http.get('${localserver}/bar/bar')!
    assert x.body == 'from bar, 3'
}

fn test_nested() {
    x := http.get('${localserver}/nested/route/method')!
    assert x.body == 'from nested, 3'
}

fn test_route_middleware_bound_method_can_access_app_state() {
    x := http.get('${localserver}/bound')!
    assert x.body == 'from app middleware, 1, from app middleware, 12'
}

fn test_route_middleware_method_filter_get() {
    x := http.get('${localserver}/admin/auth')!
    assert x.status() == .unauthorized
    assert x.body == 'auth required'
}

fn test_route_middleware_method_filter_post() {
    x := http.fetch(http.FetchConfig{
        url:    '${localserver}/admin/auth'
        method: .post
    })!
    assert x.status() == .ok
    assert x.body == 'public post route'
}

fn test_after_middleware() {
    x := http.get('${localserver}/after')!
    assert x.body == 'from after, 2'

    custom_header := x.header.get_custom('X-AFTER') or { panic('should be set!') }
    assert custom_header == '3'
}

// Verifies that encode_gzip compresses responses
fn test_encode_gzip_middleware() {
    x := http.get('${localserver}/gzip')!

    encoding := x.header.get(.content_encoding) or { '' }
    assert encoding == 'gzip', 'Expected gzip encoding, got: ${encoding}'

    // HTTP client auto-decompresses gzip content
    assert x.body == 'gzip response, 2'
}

// Verifies that decode_gzip middleware decompresses request bodies
fn test_decode_gzip_middleware() {
    original_text := 'Hello from gzip compressed body!'
    compressed := gzip.compress(original_text.bytes())!

    mut req := http.new_request(.post, '${localserver}/decode_gzip', compressed.bytestr())
    req.header.add(.content_encoding, 'gzip')
    x := req.do()!

    assert x.body == 'received: ${original_text}'
}

// Verifies that encode_zstd compresses responses
fn test_encode_zstd_middleware() {
    x := http.get('${localserver}/zstd')!

    encoding := x.header.get(.content_encoding) or { '' }
    assert encoding == 'zstd', 'Expected zstd encoding, got: ${encoding}'

    decompressed := zstd.decompress(x.body.bytes())!
    assert decompressed.bytestr() == 'zstd response, 2'
}

// Verifies that decode_zstd middleware decompresses request bodies
fn test_decode_zstd_middleware() {
    original_text := 'Hello from zstd compressed body!'
    compressed := zstd.compress(original_text.bytes())!

    mut req := http.new_request(.post, '${localserver}/decode_zstd', compressed.bytestr())
    req.header.add(.content_encoding, 'zstd')
    x := req.do()!

    assert x.body == 'received: ${original_text}'
}

// Verifies that encode_auto uses zstd when client supports it
fn test_encode_auto_zstd() {
    mut req := http.new_request(.get, '${localserver}/content', '')
    req.header.add(.accept_encoding, 'gzip, zstd, br')
    x := req.do()!

    encoding := x.header.get(.content_encoding) or { '' }
    assert encoding == 'zstd', 'Expected zstd encoding when zstd is in Accept-Encoding, got: ${encoding}'

    decompressed := zstd.decompress(x.body.bytes())!
    assert decompressed.bytestr() == 'content response, 2'
}

// Verifies that encode_auto falls back to gzip when client doesn't support zstd
fn test_encode_auto_gzip_fallback() {
    mut req := http.new_request(.get, '${localserver}/content', '')
    req.header.add(.accept_encoding, 'gzip, br')
    x := req.do()!

    encoding := x.header.get(.content_encoding) or { '' }
    assert encoding == 'gzip', 'Expected gzip encoding when zstd is not in Accept-Encoding, got: ${encoding}'

    // HTTP client auto-decompresses gzip content
    assert x.body == 'content response, 2'
}

// Verifies that encode_auto sends uncompressed when no encoding is supported
fn test_encode_auto_no_compression() {
    mut req := http.new_request(.get, '${localserver}/content', '')
    req.header.add(.accept_encoding, 'br')
    x := req.do()!

    encoding := x.header.get(.content_encoding) or { '' }
    assert encoding == '', 'Expected no encoding when neither gzip nor zstd is in Accept-Encoding, got: ${encoding}'
    assert x.body == 'content response, 2'
}

// Regression test: when global after-middleware sends response, route after-middleware should be skipped
// This tests the fix for "a response cannot be sent twice over one connection" error
fn test_double_after_middleware_no_error() {
    x := http.get('${localserver}/double_after')!
    // Global after-middleware response should be received
    assert x.body == 'global after response'
    // Route after-middleware should NOT have run (header should be absent)
    route_after_ran := x.header.get_custom('X-ROUTE-AFTER-RAN') or { '' }
    assert route_after_ran == '', 'Route after-middleware should be skipped when global already sent response'
}