// Copyright (c) 2019-2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by a GPL license that can be found in the LICENSE file.
module main

import time
import net.http
import crypto.hmac
import crypto.sha256
import encoding.hex
import json

pub struct WebhookIssuePayload {
    action string
    repo   string
    title  string
    author string
}

pub struct WebhookPrPayload {
    action string
    repo   string
    number int
    title  string
    author string
    head   string
    base   string
}

pub struct WebhookCommentPayload {
    action string
    repo   string
    target string // 'issue' or 'pr'
    number int
    author string
    text   string
}

pub struct WebhookReleasePayload {
    action string
    repo   string
    tag    string
    author string
}

pub struct WebhookPushPayload {
    repo   string
    ref    string
    author string
}

struct Webhook {
    id int @[primary; sql: serial]
mut:
    repo_id       int
    url           string
    secret        string
    events        string // comma-separated: push,issue,pr,comment,release
    is_active     bool
    created_at    int
    last_status   int
    last_delivery int
}

struct WebhookDelivery {
    id int @[primary; sql: serial]
mut:
    webhook_id    int
    event         string
    status_code   int
    response_body string
    created_at    int
}

fn (w &Webhook) has_event(name string) bool {
    if w.events == '' {
        return true
    }
    for ev in w.events.split(',') {
        if ev.trim_space() == name {
            return true
        }
    }
    return false
}

fn (w &Webhook) event_list() []string {
    mut out := []string{}
    for ev in w.events.split(',') {
        t := ev.trim_space()
        if t != '' {
            out << t
        }
    }
    return out
}

fn (mut app App) add_webhook(repo_id int, url string, secret string, events string) ! {
    wh := Webhook{
        repo_id:    repo_id
        url:        url
        secret:     secret
        events:     events
        is_active:  true
        created_at: int(time.now().unix())
    }
    sql app.db {
        insert wh into Webhook
    }!
}

fn (mut app App) list_repo_webhooks(repo_id int) []Webhook {
    return sql app.db {
        select from Webhook where repo_id == repo_id order by id desc
    } or { []Webhook{} }
}

fn (mut app App) find_webhook_by_id(id int) ?Webhook {
    rows := sql app.db {
        select from Webhook where id == id limit 1
    } or { []Webhook{} }
    if rows.len == 0 {
        return none
    }
    return rows.first()
}

fn (mut app App) delete_webhook(id int) ! {
    sql app.db {
        delete from Webhook where id == id
    }!
    sql app.db {
        delete from WebhookDelivery where webhook_id == id
    }!
}

fn (mut app App) delete_repo_webhooks(repo_id int) ! {
    whs := app.list_repo_webhooks(repo_id)
    for wh in whs {
        app.delete_webhook(wh.id) or {}
    }
}

fn (mut app App) toggle_webhook(id int, active bool) ! {
    sql app.db {
        update Webhook set is_active = active where id == id
    }!
}

fn (mut app App) record_webhook_delivery(webhook_id int, event string, status int, body string) {
    d := WebhookDelivery{
        webhook_id:    webhook_id
        event:         event
        status_code:   status
        response_body: body
        created_at:    int(time.now().unix())
    }
    sql app.db {
        insert d into WebhookDelivery
    } or { return }
    sql app.db {
        update Webhook set last_status = status, last_delivery = d.created_at where id == webhook_id
    } or { return }
}

fn (mut app App) recent_webhook_deliveries(webhook_id int, limit int) []WebhookDelivery {
    return sql app.db {
        select from WebhookDelivery where webhook_id == webhook_id order by id desc limit limit
    } or { []WebhookDelivery{} }
}

// dispatch_webhook fires a webhook delivery in a background spawn.
// payload is any serializable value; it's JSON-encoded with `json.encode`.
fn (mut app App) dispatch_webhook[T](repo_id int, event string, payload T) {
    body := json.encode(payload)
    app.fan_out_webhook(repo_id, event, body)
}

fn (mut app App) fan_out_webhook(repo_id int, event string, body string) {
    hooks := app.list_repo_webhooks(repo_id)
    for wh in hooks {
        if !wh.is_active {
            continue
        }
        if !wh.has_event(event) {
            continue
        }
        spawn app.deliver_webhook(wh, event, body)
    }
}

fn (mut app App) deliver_webhook(wh Webhook, event string, body string) {
    mut signature := ''
    if wh.secret != '' {
        sig_bytes := hmac.new(wh.secret.bytes(), body.bytes(), sha256.sum, sha256.block_size)
        signature = 'sha256=' + hex.encode(sig_bytes)
    }
    mut req := http.new_request(.post, wh.url, body)
    req.header.add(.content_type, 'application/json')
    req.header.add_custom('X-Gitly-Event', event) or {}
    if signature != '' {
        req.header.add_custom('X-Gitly-Signature', signature) or {}
    }
    req.read_timeout = 10 * time.second
    req.write_timeout = 10 * time.second
    resp := req.do() or {
        app.record_webhook_delivery(wh.id, event, 0, err.str())
        return
    }
    preview := if resp.body.len > 500 { resp.body[..500] } else { resp.body }
    app.record_webhook_delivery(wh.id, event, resp.status_code, preview)
}