package db

import (
	"context"
	"github.com/jackc/pgx/v5/pgtype"
	"lmika.dev/lmika/hugo-cms/gen/sqlc/dbq"
	"lmika.dev/lmika/hugo-cms/models"
	"lmika.dev/pkg/modash/momap"
	"lmika.dev/pkg/modash/moslice"
)

var nameProvenanceToDBNameProvenance = map[models.NameProvenance]dbq.PageNameProvenance{
	models.UserNameProvenance:  dbq.PageNameProvenanceUser,
	models.TitleNameProvenance: dbq.PageNameProvenanceTitle,
	models.DateNameProvenance:  dbq.PageNameProvenanceDate,
}
var dbNameProvenanceToNameProvenance = momap.ReverseMap(nameProvenanceToDBNameProvenance)

var pageRoleToDBPageRole = map[models.PageRole]dbq.NullPageRole{
	models.NormalPageRole: {},
	models.IndexPageRole:  {PageRole: dbq.PageRoleIndex, Valid: true},
}
var dbPageRoleToPageRole = momap.ReverseMap(pageRoleToDBPageRole)

func (db *DB) InsertPage(ctx context.Context, page *models.Page) error {

	id, err := db.q.InsertPage(ctx, dbq.InsertPageParams{
		SiteID:         page.SiteID,
		BundleID:       page.BundleID,
		Name:           page.Name,
		NameProvenance: nameProvenanceToDBNameProvenance[page.NameProvenance],
		Role:           pageRoleToDBPageRole[page.Role],
		Title:          pgtype.Text{String: page.Title, Valid: page.Title != ""},
		Body:           page.Body,
		State:          dbq.PostState(page.State),
		Props:          []byte(`{}`),
		PublishDate:    pgtype.Timestamptz{Time: page.PublishDate, Valid: !page.PublishDate.IsZero()},
		CreatedAt:      pgtype.Timestamp{Time: page.CreatedAt, Valid: true},
	})
	if err != nil {
		return err
	}
	page.ID = id
	return nil
}

func (db *DB) UpdatePage(ctx context.Context, page *models.Page) error {
	return db.q.UpdatePage(ctx, dbq.UpdatePageParams{
		ID:             page.ID,
		SiteID:         page.SiteID,
		BundleID:       page.BundleID,
		Name:           page.Name,
		Role:           pageRoleToDBPageRole[page.Role],
		NameProvenance: nameProvenanceToDBNameProvenance[page.NameProvenance],
		Title:          pgtype.Text{String: page.Title, Valid: page.Title != ""},
		Body:           page.Body,
		State:          dbq.PostState(page.State),
		Props:          []byte(`{}`),
		PublishDate:    pgtype.Timestamptz{Time: page.PublishDate, Valid: true},
		CreatedAt:      pgtype.Timestamp{Time: page.CreatedAt, Valid: true},
		UpdatedAt:      pgtype.Timestamp{Time: page.UpdatedAt, Valid: true},
	})
}

func (db *DB) ListPagesOfSite(ctx context.Context, siteID int64) ([]models.Page, error) {
	res, err := db.q.ListPages(ctx, siteID)
	if err != nil {
		return nil, err
	}

	return moslice.Map(res, dbPageToPage), nil
}

func (db *DB) ListPublishablePages(ctx context.Context, fromID, siteID int64) ([]models.Page, error) {
	res, err := db.q.ListPublishablePages(ctx, dbq.ListPublishablePagesParams{
		ID:     fromID,
		SiteID: siteID,
	})
	if err != nil {
		return nil, err
	}

	return moslice.Map(res, dbPageToPage), nil
}

func (db *DB) GetPage(ctx context.Context, postID int64) (models.Page, error) {
	res, err := db.q.GetPageWithID(ctx, postID)
	if err != nil {
		return models.Page{}, err
	}

	return dbPageToPage(res), nil
}

func (db *DB) DeletePage(ctx context.Context, pageID int64) error {

	return db.q.DeletePageWithID(ctx, pageID)
}

func dbPageToPage(p dbq.Page) models.Page {
	return models.Page{
		ID:             p.ID,
		SiteID:         p.SiteID,
		BundleID:       p.BundleID,
		Name:           p.Name,
		Role:           dbPageRoleToPageRole[p.Role],
		NameProvenance: dbNameProvenanceToNameProvenance[p.NameProvenance],
		Title:          p.Title.String,
		Body:           p.Body,
		State:          models.PostState(p.State),
		PublishDate:    p.PublishDate.Time,
		CreatedAt:      p.CreatedAt.Time,
	}
}