// vtest build: present_sqlite3? && !windows // present_sqlite3?: imports db.sqlite; !windows: fasthttp.Server.run not implemented
import veb
import time
import net.http
import db.sqlite

const port = 13004

pub struct Context {
    veb.Context
pub mut:
    cid int
}

pub fn (mut ctx Context) before_request() {
    dump(@LOCATION)
    ctx.cid = 123
}

pub struct App {
pub mut:
    db      sqlite.DB
    started chan bool
}

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

struct Article {
    id    int
    title string
    text  string
}

fn test_veb_application_compiles() {
    spawn fn () {
        time.sleep(15 * time.second)
        exit(0)
    }()
    mut app := &App{}
    spawn veb.run_at[App, Context](mut app, port: port, family: .ip, timeout_in_seconds: 2)
    // app startup time
    _ := <-app.started
    res := http.fetch(url: 'http://127.0.0.1:${port}/get_cid')!
    assert res.status_code == 200
    assert res.body == '123'
    okres := http.fetch(url: 'http://127.0.0.1:${port}/ok')!
    assert okres.status_code == 200
    assert okres.body == '{"success":true,"result":123}'
    hello := http.fetch(url: 'http://127.0.0.1:${port}/hello')!
    assert hello.status_code == 200
    assert hello.body == 'hello world'
}

@['/new_article'; post]
pub fn (mut app App) new_article(mut ctx Context) veb.Result {
    title := ctx.form['title']
    text := ctx.form['text']
    if title == '' || text == '' {
        return ctx.text('Empty text/title')
    }
    article := Article{
        title: title
        text:  text
    }
    println('posting article')
    println(article)
    sql app.db {
        insert article into Article
    } or {}

    return ctx.redirect('/', typ: .see_other)
}

pub fn (mut app App) time(mut ctx Context) veb.Result {
    return ctx.text(time.now().format())
}

pub fn (mut app App) time_json(mut ctx Context) veb.Result {
    return ctx.json({
        'time': time.now().format()
    })
}

fn (app App) hello(mut ctx Context) veb.Result {
    return ctx.text('hello world')
}

fn (mut app App) time_json_pretty(mut ctx Context) veb.Result {
    return ctx.json_pretty({
        'time': time.now().format()
    })
}

struct ApiSuccessResponse[T] {
    success bool
    result  T
}

fn (mut app App) json_success[T](mut ctx Context, result T) {
    response := ApiSuccessResponse[T]{
        success: true
        result:  result
    }

    ctx.json(response)
}

// should compile, this is a helper method, not exposed as a route
fn (mut app App) some_helper[T](result T) ApiSuccessResponse[T] {
    response := ApiSuccessResponse[T]{
        success: true
        result:  result
    }
    return response
}

// should compile, the route method itself is not generic
fn (mut app App) ok(mut ctx Context) veb.Result {
    return ctx.json(app.some_helper(ctx.cid))
}

// should compile, the route method itself is not generic
fn (mut app App) get_cid(mut ctx Context) veb.Result {
    return ctx.text(ctx.cid.str())
}

struct ExampleStruct {
    example int
}

fn (mut app App) request_raw_2(mut ctx Context) veb.Result {
    stuff := []ExampleStruct{}
    app.request_raw(mut ctx, stuff)
    return ctx.ok('')
}

// should compile, this is a helper method, not exposed as a route
fn (mut app App) request_raw(mut ctx Context, foo []ExampleStruct) {
    ctx.text('Hello world')
}