package api

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"net/http"
	"time"

	"atlas9.dev/c/core/dbi"
	"atlas9.dev/c/demo/lib/domains"
	"atlas9.dev/c/demo/tasks"
)

type DomainImpl struct {
	DB    *sql.DB
	Store dbi.Factory[domains.Store]
	Tasks dbi.Factory[tasks.Producer]
}

func (d *DomainImpl) Create(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	var req Domain_CreateReq
	if read(w, r, &req) {
		return
	}

	dom := domains.NewDomain(req.Tenant, req.Domain)

	err := dbi.ReadWrite(ctx, d.DB, func(tx dbi.DBI) error {

		err := d.Store(tx).Create(ctx, &dom)
		if err != nil {
			return err
		}

		payload, err := json.Marshal(Domain_VerifyReq{
			ID:     dom.ID,
			Tenant: req.Tenant,
		})
		if err != nil {
			return err
		}

		return d.Tasks(tx).Push(ctx, "Domain_Verify", payload)
	})

	write(ctx, w, err, Domain_CreateRes{Domain: dom})
}

func (d *DomainImpl) Get(w http.ResponseWriter, r *http.Request) {}

func (d *DomainImpl) List(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	var req Domain_ListReq
	if read(w, r, &req) {
		return
	}

	var res Domain_ListRes
	err := dbi.ReadOnly(ctx, d.DB, func(tx dbi.DBI) error {
		return d.Store(tx).List(ctx, req.Tenant, req.Page, &res.Page)
	})
	if err != nil {
		writeErr(ctx, w, err)
		return
	}

	write(ctx, w, nil, res)
}

func (d *DomainImpl) Delete(w http.ResponseWriter, r *http.Request) {}

func (d *DomainImpl) Verify(w http.ResponseWriter, r *http.Request) {

	ctx := r.Context()

	var req Domain_VerifyReq
	if read(w, r, &req) {
		return
	}

	var dom domains.Domain
	err := dbi.ReadOnly(ctx, d.DB, func(tx dbi.DBI) error {
		return d.Store(tx).Get(ctx, req.Tenant, req.ID, &dom)
	})
	if writeErr(ctx, w, wrap("reading domain", err)) {
		return
	}

	found, err := domains.VerifyDomain(dom.Domain, req.ID.String())
	res := Domain_VerifyRes{
		Verified: found,
	}

	if !found || err != nil {
		write(ctx, w, err, res)
		return
	}

	err = dbi.ReadWrite(ctx, d.DB, func(tx dbi.DBI) error {
		return d.Store(tx).SetVerifiedAt(ctx, req.Tenant, req.ID, time.Now())
	})
	write(ctx, w, err, res)
}

func wrap(msg string, err error) error {
	if err == nil {
		return nil
	}
	return fmt.Errorf("%s: %w", msg, err)
}