package repository

import (
	"reflect"
	"strings"

	"git.gdulai.com/gdulai/simpleorm"
	"git.gdulai.com/gdulai/simpleorm/exec"
	log "gitlab.com/gdulai/simpleloglvl"
)

type HasPK interface {
	IsInsertable() bool
}

type Repository[T HasPK] struct {
	conn *simpleorm.DBConnection
	orm  *simpleorm.ORM
}

func NewRepository[T HasPK](conn *simpleorm.DBConnection, orm *simpleorm.ORM) *Repository[T] {
	return &Repository[T]{conn: conn, orm: orm}
}

func (r *Repository[T]) SelectAll() []*T {
	selectExec, err := exec.CreateSelect[T](r.orm, "")
	if err != nil {
		log.LogError("Failed to create select execution: %s", err)
		return []*T{}
	}

	selecRes, err := selectExec.Execute(r.conn)
	if err != nil {
		log.LogError("Failed to load projects: %s", err)
		return []*T{}
	}

	res := make([]*T, 0, len(selecRes))
	for i := range selecRes {
		res = append(res, &selecRes[i])
	}

	return res
}

func (r *Repository[T]) SelectByPk(pks ...any) *T {
	table, ok := r.orm.Cache().Get(reflect.TypeFor[T]().Name())
	if !ok {
		log.LogError("Could not get cached Table!")
		return nil
	}

	var whereStmtBuilder strings.Builder

	for _, constr := range table.Constraints {
		if constr.Type != "pk" {
			continue
		}

		for i, col := range constr.Columns {
			if i != 0 {
				whereStmtBuilder.WriteString(" AND ")
			}

			whereStmtBuilder.WriteString(col.Name + " = ?")
		}

	}

	selectExec, err := exec.CreateSelect[T](r.orm, whereStmtBuilder.String(), pks)
	if err != nil {
		log.LogError("Failed to create select execution: %s", err)
		return nil
	}

	res, err := selectExec.Execute(r.conn)
	if err != nil {
		log.LogError("Failed to load entity: %s", err)
		return nil
	}

	if len(res) != 1 {
		log.LogError("Invalid result number of results: %s", len(res))
		return nil
	}

	return &res[0]
}

func (r *Repository[T]) Save(entity T) {
	// Insert
	if entity.IsInsertable() {
		insertExec, err := exec.NewInsert[T](r.orm, entity)
		if err != nil {
			log.LogError("Failed to create insert execution: %s", err)
			return
		}
		if _, err := insertExec.Execute(r.conn); err != nil {
			log.LogError("Insert failed for entity: %s", entity)
		}

		return
	}

	updateExec, err := exec.NewUpdate[T](r.orm, entity)
	if err != nil {
		log.LogError("Failed to create update execution: %s", err)
		return
	}

	_, err = updateExec.Execute(r.conn)
	if err != nil {
		log.LogError("Update failed: %s", err)
		return
	}
}

func (r *Repository[T]) Delete(entity T) {
	deleteExec, err := exec.NewDelete[T](r.orm, []T{entity})
	if err != nil {
		log.LogError("Failed to create delete execution: %s", err)
		return
	}
	_, err = deleteExec.Execute(r.conn)
	if err != nil {
		log.LogError("Delete failed: %s", err)
		return
	}
}