module main

import db.sqlite
import flag
import json
import os
import rand
import time
import vbugreport
import veb

const default_port = 8080
const max_report_body_bytes = 256 * 1024

struct ReportLine {
pub:
    line int
    text string
}

struct BugReport {
pub:
    kind           string
    v_version      string
    target_os      string
    target_backend string
    ccompiler      string
    c_error        string
    c_file         string
    c_line         int
    c_context      []ReportLine
    v_file         string
    v_line         int
    v_context      []ReportLine
}

struct CreateBugReportResponse {
pub:
    id           string
    delete_url   string
    delete_token string
    message      string
}

struct DeleteBugReportResponse {
pub:
    id      string
    deleted bool
    message string
}

struct ServerConfig {
    host       string
    port       int
    db_path    string
    public_url string
}

pub struct App {
pub:
    public_url string
pub mut:
    db sqlite.DB
}

pub struct Context {
    veb.Context
}

fn args_without_command() []string {
    args := os.args#[1..]
    if args.len > 0 && args[0] == 'bug-report' {
        return args[1..]
    }
    return args
}

fn db_path_from_env() string {
    db_path := os.getenv('V_BUG_REPORT_DB')
    if db_path != '' {
        return db_path
    }
    report_dir := os.getenv('V_BUG_REPORT_DIR')
    if report_dir != '' {
        return os.join_path(report_dir, 'bug_reports.sqlite')
    }
    return os.join_path(os.getwd(), 'bug_reports.sqlite')
}

fn report_host_from_env() string {
    host := os.getenv('V_BUG_REPORT_HOST')
    if host != '' {
        return host
    }
    return 'localhost'
}

fn report_port_from_env() int {
    bug_report_port := os.getenv('V_BUG_REPORT_PORT')
    if bug_report_port != '' {
        return bug_report_port.int()
    }
    port := os.getenv('PORT')
    if port != '' {
        return port.int()
    }
    return default_port
}

fn public_url_from_config(flag_url string, host string, port int) string {
    url := if flag_url != '' { flag_url } else { os.getenv('V_BUG_REPORT_PUBLIC_URL') }
    if url != '' {
        return url.trim_space().trim_right('/')
    }
    public_host := if host == '' || host == '0.0.0.0' { 'localhost' } else { host }
    return 'http://${public_host}:${port}/bug-report'
}

fn config_from_args() !ServerConfig {
    mut fp := flag.new_flag_parser(args_without_command())
    fp.application('v bug-report')
    fp.version('0.0.1')
    fp.description('Run the V compiler bug report receiver.')
    fp.arguments_description('')
    show_help := fp.bool('help', `h`, false, 'Show this help screen.')
    host := fp.string('host', 0, report_host_from_env(), 'Host to listen on.')
    port := fp.int('port', `p`, report_port_from_env(), 'Port to listen on.')
    db_path := fp.string('db', 0, db_path_from_env(), 'SQLite database path.')
    public_url_arg := fp.string('public-url', 0, '', 'Public /bug-report endpoint URL.')
    if show_help {
        println(fp.usage())
        exit(0)
    }
    remaining := fp.finalize()!
    if remaining.len > 0 {
        return error('unexpected arguments: ${remaining.join(' ')}')
    }
    return ServerConfig{
        host:       host
        port:       port
        db_path:    db_path
        public_url: public_url_from_config(public_url_arg, host, port)
    }
}

fn safe_id(id string) bool {
    if id.len < 8 || id.len > 80 {
        return false
    }
    for ch in id {
        if !ch.is_letter() && !ch.is_digit() && ch != `-` && ch != `_` {
            return false
        }
    }
    return true
}

fn new_report_id() string {
    return rand.uuid_v4()
}

fn (app App) delete_url(id string, token string) string {
    return '${app.public_url}/${id}?token=${token}'
}

fn delete_token_from_request(ctx Context) string {
    if token := ctx.query['token'] {
        return token
    }
    return ctx.get_custom_header('X-Delete-Token') or { '' }
}

fn ensure_db_parent(db_path string) ! {
    if db_path == ':memory:' || db_path.starts_with('file:') {
        return
    }
    parent_dir := os.dir(db_path)
    if parent_dir != '' && parent_dir != '.' {
        os.mkdir_all(parent_dir)!
    }
}

fn connect_db(db_path string) !sqlite.DB {
    ensure_db_parent(db_path)!
    mut db := sqlite.connect_full(db_path, [.readwrite, .create, .fullmutex], '')!
    db.busy_timeout(3000)
    return db
}

fn init_db(db sqlite.DB) ! {
    db.exec("create table if not exists bug_reports (
            id text primary key,
            delete_token text not null,
            created_at text not null,
            remote_ip text not null,
                user_agent text not null,
                c_file_name text not null,
                target_os text not null,
                ccompiler text not null,
                error_string text not null,
                lines text not null,
                v_lines text not null default ''
            )")!
    // Add columns that were introduced after the table already existed, so older
    // databases pick them up without losing their stored reports.
    ensure_column(db, 'bug_reports', 'v_lines', "text not null default ''")!
    db.exec('create index if not exists idx_bug_reports_created_at
            on bug_reports(created_at)')!
}

// ensure_column adds `column` to `table` when it is not present yet. SQLite has no
// `add column if not exists`, so the existing columns are inspected first.
fn ensure_column(db sqlite.DB, table string, column string, definition string) ! {
    rows := db.exec('pragma table_info(${table})')!
    for row in rows {
        // pragma table_info columns are: cid, name, type, notnull, dflt_value, pk
        if row.vals.len > 1 && row.vals[1] == column {
            return
        }
    }
    db.exec('alter table ${table} add column ${column} ${definition}')!
}

// create stores a compiler bug report and returns its deletion token.
@['/bug-report'; post]
pub fn (mut app App) create(mut ctx Context) veb.Result {
    if ctx.req.data.len == 0 {
        return ctx.request_error('empty report body')
    }
    if ctx.req.data.len > max_report_body_bytes {
        ctx.res.set_status(.bad_request)
        return ctx.text('report body is too large')
    }
    report := json.decode(BugReport, ctx.req.data) or {
        return ctx.request_error('invalid report JSON: ${err}')
    }
    if report.kind != 'v-c-compiler-error' {
        return ctx.request_error('unsupported report kind')
    }
    stored_report := vbugreport.new_stored_c_error_report(report.c_file, report.target_os,
        report.ccompiler, report.c_error, report.c_context.map(it.text),
        report.v_context.map(it.text))
    id := new_report_id()
    delete_token := rand.uuid_v4()
    app.db.exec_param_many('insert into bug_reports (
                id, delete_token, created_at, remote_ip, user_agent,
                c_file_name, target_os, ccompiler, error_string, lines, v_lines
            ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', [
        id,
        delete_token,
        time.utc().format_rfc3339(),
        ctx.ip(),
        ctx.user_agent(),
        stored_report.c_file_name,
        stored_report.target_os,
        stored_report.ccompiler,
        stored_report.error_string,
        stored_report.lines,
        stored_report.v_lines,
    ]) or { return ctx.server_error('could not store report') }
    return ctx.json(CreateBugReportResponse{
        id:           id
        delete_url:   app.delete_url(id, delete_token)
        delete_token: delete_token
        message:      'created'
    })
}

// delete removes a compiler bug report when the deletion token matches.
@['/bug-report/:id'; delete]
pub fn (mut app App) delete(mut ctx Context, id string) veb.Result {
    if !safe_id(id) {
        return ctx.request_error('invalid report id')
    }
    rows := app.db.exec_param('select delete_token from bug_reports where id = ?', id) or {
        return ctx.server_error('could not read report')
    }
    if rows.len == 0 {
        return ctx.not_found()
    }
    if delete_token_from_request(ctx) != rows[0].vals[0] {
        ctx.res.set_status(.forbidden)
        return ctx.text('invalid delete token')
    }
    app.db.exec_param('delete from bug_reports where id = ?', id) or {
        return ctx.server_error('could not delete report')
    }
    return ctx.json(DeleteBugReportResponse{
        id:      id
        deleted: true
        message: 'deleted'
    })
}

// healthz returns a basic readiness response for local checks.
@['/healthz'; get]
pub fn (mut app App) healthz(mut ctx Context) veb.Result {
    return ctx.text('ok')
}

fn main() {
    config := config_from_args() or {
        eprintln('v bug-report: ${err}')
        exit(1)
    }
    mut db := connect_db(config.db_path) or { panic(err) }
    init_db(db) or { panic(err) }
    mut app := &App{
        public_url: config.public_url
        db:         db
    }
    veb.run_at[App, Context](mut app, host: config.host, port: config.port, family: .ip) or {
        panic(err)
    }
}