package main

import (
	"context"
	"database/sql"

	"atlas9.dev/c/core"
	"atlas9.dev/c/core/dbi"
	"atlas9.dev/c/core/iam"
	"atlas9.dev/c/core/routes"
)

type TenantApi struct {
	DB      *sql.DB
	Tenants dbi.Factory[iam.TenantStore]
}

type GetTenantReq struct {
	ID core.ID
}

type DeleteTenantReq struct {
	ID core.ID
}

type DeleteTenantRes struct{}

type ListTenantsReq struct {
	Page core.PageReq
}

type ListTenantsRes core.Page[iam.Tenant]

func (s *TenantApi) Save(ctx context.Context, req iam.Tenant) (*iam.Tenant, error) {
	_, err := dbi.ReadWrite(ctx, s.DB, func(tx dbi.DBI) (bool, error) {
		return s.Tenants(tx).Save(ctx, &req)
	})
	if err != nil {
		return nil, err
	}
	return &req, nil
}

func (s *TenantApi) Get(ctx context.Context, req GetTenantReq) (*iam.Tenant, error) {
	return dbi.ReadOnly(ctx, s.DB, func(tx dbi.DBI) (*iam.Tenant, error) {
		return s.Tenants(tx).Get(ctx, req.ID)
	})
}

func (s *TenantApi) Delete(ctx context.Context, req DeleteTenantReq) (*DeleteTenantRes, error) {
	return dbi.ReadWrite(ctx, s.DB, func(tx dbi.DBI) (*DeleteTenantRes, error) {
		return &DeleteTenantRes{}, s.Tenants(tx).Delete(ctx, req.ID)
	})
}

func (s *TenantApi) List(ctx context.Context, req ListTenantsReq) (*ListTenantsRes, error) {
	page, err := dbi.ReadOnly(ctx, s.DB, func(tx dbi.DBI) (core.Page[iam.Tenant], error) {
		return s.Tenants(tx).List(ctx, req.Page)
	})
	if err != nil {
		return nil, err
	}
	res := ListTenantsRes(page)
	return &res, nil
}

func TenantRoutes(svc *TenantApi) []routes.Route {
	return []routes.Route{
		routes.RPC("/tenants/save", svc.Save),
		routes.RPC("/tenants/get", svc.Get),
		routes.RPC("/tenants/delete", svc.Delete),
		routes.RPC("/tenants/list", svc.List),
	}
}