package api_impl

import (
	"database/sql"
	"net/http"

	"atlas9.dev/c/core"
	"atlas9.dev/c/core/dbi"
	"atlas9.dev/c/core/iam"
	"atlas9.dev/c/demo/api"
	"atlas9.dev/c/demo/bots"
	"atlas9.dev/c/demo/lib/access"
)

type BotsImpl struct {
	DB    *sql.DB
	Guard access.Guard
	Store dbi.Factory[bots.BotStore]
	Audit dbi.Factory[iam.AuditStore]
}

func (b *BotsImpl) ServeMux(mux *http.ServeMux) {
	mux.HandleFunc(api.Path_Bots_Save, b.Save)
	mux.HandleFunc(api.Path_Bots_Get, b.Get)
	mux.HandleFunc(api.Path_Bots_List, b.List)
	mux.HandleFunc(api.Path_Bots_Delete, b.Delete)
}

func (b *BotsImpl) Save(w http.ResponseWriter, r *http.Request) {

	var req api.Bots_SaveReq
	if read(w, r, &req) {
		return
	}

	if check(w, r, b.Guard, bots.Cap_Bots_Write, req.Bot.Tenant, "") {
		return
	}

	ctx := r.Context()
	err := dbi.ReadWrite(ctx, b.DB, func(tx dbi.DBI) error {
		if err := b.Store(tx).Save(ctx, &req.Bot); err != nil {
			return err
		}
		return audit(ctx, b.Audit(tx), iam.AuditEntry{
			Tenant:   req.Bot.Tenant,
			Action:   "Bots_Save",
			Resource: req.Bot.ID.String(),
			Detail:   req.Bot.Name,
		})
	})

	write(ctx, w, err, api.Bots_SaveRes{Bot: req.Bot})
}

func (b *BotsImpl) Get(w http.ResponseWriter, r *http.Request) {

	var req api.Bots_GetReq
	if read(w, r, &req) {
		return
	}

	if check(w, r, b.Guard, bots.Cap_Bots_Read, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	var bot bots.Bot
	err := dbi.ReadOnly(ctx, b.DB, func(tx dbi.DBI) error {
		return b.Store(tx).Get(ctx, req.Tenant, req.ID, &bot)
	})

	write(ctx, w, err, api.Bots_GetRes{Bot: bot})
}

func (b *BotsImpl) List(w http.ResponseWriter, r *http.Request) {

	var req api.Bots_ListReq
	if read(w, r, &req) {
		return
	}

	if check(w, r, b.Guard, bots.Cap_Bots_Read, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	var page core.Page[bots.Bot]
	err := dbi.ReadOnly(ctx, b.DB, func(tx dbi.DBI) error {
		return b.Store(tx).List(ctx, req.Tenant, req.Page, &page)
	})

	var res api.Bots_ListRes
	res.Page.Cursor = page.Cursor
	res.Page.Items = page.Items

	write(ctx, w, err, res)
}

func (b *BotsImpl) Delete(w http.ResponseWriter, r *http.Request) {

	var req api.Bots_DeleteReq
	if read(w, r, &req) {
		return
	}

	if check(w, r, b.Guard, bots.Cap_Bots_Write, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	err := dbi.ReadWrite(ctx, b.DB, func(tx dbi.DBI) error {
		if err := b.Store(tx).Delete(ctx, req.Tenant, req.ID); err != nil {
			return err
		}
		return audit(ctx, b.Audit(tx), iam.AuditEntry{
			Tenant:   req.Tenant,
			Action:   "Bots_Delete",
			Resource: req.ID.String(),
		})
	})

	write(ctx, w, err, api.Bots_DeleteRes{})
}