package api_impl

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

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

type TodosImpl struct {
	DB    *sql.DB
	Guard access.Guard
	Store dbi.Factory[todos.Store]
	Audit dbi.Factory[iam.AuditStore]
}

func (s *TodosImpl) ServeMux(mux *http.ServeMux) {
	mux.HandleFunc(api.Path_Todos_CreateList, s.CreateList)
	mux.HandleFunc(api.Path_Todos_UpdateList, s.UpdateList)
	mux.HandleFunc(api.Path_Todos_GetList, s.GetList)
	mux.HandleFunc(api.Path_Todos_ListLists, s.ListLists)
	mux.HandleFunc(api.Path_Todos_DeleteList, s.DeleteList)
	mux.HandleFunc(api.Path_Todos_AddToList, s.AddToList)
	mux.HandleFunc(api.Path_Todos_RemoveFromList, s.RemoveFromList)
	mux.HandleFunc(api.Path_Todos_CreateItem, s.CreateItem)
	mux.HandleFunc(api.Path_Todos_UpdateItem, s.UpdateItem)
	mux.HandleFunc(api.Path_Todos_GetItem, s.GetItem)
	mux.HandleFunc(api.Path_Todos_ListItems, s.ListItems)
	mux.HandleFunc(api.Path_Todos_DeleteItem, s.DeleteItem)
}

func (s *TodosImpl) CreateList(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_CreateList, req.List.Tenant, "") {
		return
	}

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

	write(ctx, w, err, api.Todos_CreateListRes{List: req.List})
}

func (s *TodosImpl) UpdateList(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_UpdateList, req.List.Tenant, "") {
		return
	}

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

	write(ctx, w, err, api.Todos_UpdateListRes{List: req.List})
}

func (s *TodosImpl) GetList(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_ReadList, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	var res api.Todos_GetListRes
	err := dbi.ReadOnly(ctx, s.DB, func(tx dbi.DBI) error {
		return s.Store(tx).GetList(ctx, req.Tenant, req.ID, &res.List)
	})

	write(ctx, w, err, res)
}

func (s *TodosImpl) ListLists(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_ReadList, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	var res api.Todos_ListListsRes
	err := dbi.ReadOnly(ctx, s.DB, func(tx dbi.DBI) error {
		return s.Store(tx).ListLists(ctx, req.Tenant, req.Page, &res.Page)
	})

	write(ctx, w, err, res)
}

func (s *TodosImpl) DeleteList(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_DeleteList, req.Tenant, "") {
		return
	}

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

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

func (s *TodosImpl) AddToList(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_AddToList, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	err := dbi.ReadWrite(ctx, s.DB, func(tx dbi.DBI) error {
		if err := s.Store(tx).AddToList(ctx, req.Tenant, req.List, req.Item); err != nil {
			return err
		}
		return audit(ctx, s.Audit(tx), iam.AuditEntry{
			Tenant:   req.Tenant,
			Action:   "Todos_AddToList",
			Resource: req.List.String(),
			Detail:   req.Item.String(),
		})
	})

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

func (s *TodosImpl) RemoveFromList(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_RemoveFromList, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	err := dbi.ReadWrite(ctx, s.DB, func(tx dbi.DBI) error {
		if err := s.Store(tx).RemoveFromList(ctx, req.Tenant, req.List, req.Item); err != nil {
			return err
		}
		return audit(ctx, s.Audit(tx), iam.AuditEntry{
			Tenant:   req.Tenant,
			Action:   "Todos_RemoveFromList",
			Resource: req.List.String(),
			Detail:   req.Item.String(),
		})
	})

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

func (s *TodosImpl) CreateItem(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_CreateItem, req.Item.Tenant, "") {
		return
	}

	ctx := r.Context()
	err := dbi.ReadWrite(ctx, s.DB, func(tx dbi.DBI) error {
		if err := s.Store(tx).CreateItem(ctx, &req.Item); err != nil {
			return err
		}
		return audit(ctx, s.Audit(tx), iam.AuditEntry{
			Tenant:   req.Item.Tenant,
			Action:   "Todos_CreateItem",
			Resource: req.Item.ID.String(),
			Detail:   req.Item.Title,
		})
	})

	write(ctx, w, err, api.Todos_CreateItemRes{Item: req.Item})
}

func (s *TodosImpl) UpdateItem(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_UpdateItem, req.Item.Tenant, "") {
		return
	}

	ctx := r.Context()
	err := dbi.ReadWrite(ctx, s.DB, func(tx dbi.DBI) error {
		if err := s.Store(tx).UpdateItem(ctx, &req.Item); err != nil {
			return err
		}
		return audit(ctx, s.Audit(tx), iam.AuditEntry{
			Tenant:   req.Item.Tenant,
			Action:   "Todos_UpdateItem",
			Resource: req.Item.ID.String(),
			Detail:   req.Item.Title,
		})
	})

	write(ctx, w, err, api.Todos_UpdateItemRes{Item: req.Item})
}

func (s *TodosImpl) GetItem(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_ReadItem, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	var res api.Todos_GetItemRes
	err := dbi.ReadOnly(ctx, s.DB, func(tx dbi.DBI) error {
		return s.Store(tx).GetItem(ctx, req.Tenant, req.ID, &res.Item)
	})

	write(ctx, w, err, res)
}

func (s *TodosImpl) ListItems(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_ReadItem, req.Tenant, "") {
		return
	}

	ctx := r.Context()
	var res api.Todos_ListItemsRes
	err := dbi.ReadOnly(ctx, s.DB, func(tx dbi.DBI) error {
		return s.Store(tx).ListItems(ctx, req.Tenant, req.List, req.Page, &res.Page)
	})

	write(ctx, w, err, res)
}

func (s *TodosImpl) DeleteItem(w http.ResponseWriter, r *http.Request) {

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

	if check(w, r, s.Guard, todos.Cap_Todos_DeleteItem, req.Tenant, "") {
		return
	}

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

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