package dokter

import (
	"antrian-operasi/internal/database"
	"antrian-operasi/internal/shared"
	"errors"
	"log"

	queryUtils "antrian-operasi/internal/utils/query"

	"github.com/gin-gonic/gin"
)

const DB_NAME = "db_antrian"
const TBL_NAME = "data_pegawai"

type IDokterRepository interface {
	SearchableListDokter(c *gin.Context) (ListDokterModelPaginate, error)
	GetDokterById(c *gin.Context, id string) (DokterModel, error)
}

type dokterRepo struct {
	queryBuilder *queryUtils.QueryBuilder
	db           database.Service
}

func NewRepository(dbService database.Service) IDokterRepository {
	queryBuilder := queryUtils.NewQueryBuilder(queryUtils.DBTypePostgreSQL).
		SetAllowedColumns([]string{
			"id",
			"nip",
			"nama_depan",
			"nama_belakang",
			"hfis_code",
			"nama_ksm",
		})
	queryBuilder.SetSecurityOptions(false, 100)

	return dokterRepo{
		queryBuilder: queryBuilder,
		db:           dbService,
	}
}

func baseSelectQuery() queryUtils.DynamicQuery {
	query := queryUtils.DynamicQuery{
		From:    TBL_NAME,
		Aliases: "dp",
		Fields: []queryUtils.SelectField{
			{Expression: "dp.id", Alias: "id"},
			{Expression: "dp.NIP", Alias: "nip"},
			{Expression: "dp.Nama_depan", Alias: "nama_depan"},
			{Expression: "dp.Nama_belakang", Alias: "nama_belakang"},
			{Expression: "HFIS_code", Alias: "hfis_code"},
			{Expression: "dk.Nama_ksm", Alias: "nama_ksm"},
		},
	}

	query.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "daftar_ksm",
			Alias: "dk",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{
						Column: "dk.id", Operator: queryUtils.OpEqual, Value: "dp.KSM",
					},
				},
			},
		},
	}

	return query
}

func (r dokterRepo) SearchableListDokter(c *gin.Context) (ListDokterModelPaginate, error) {
	var result ListDokterModelPaginate
	limit := shared.ParseQueryLimit(c)
	offset := shared.ParseQueryOffset(c)
	search := c.Query("search")

	// base query
	query := baseSelectQuery()

	// base filtering
	var baseFilter []queryUtils.DynamicFilter
	baseFilter = append(baseFilter, queryUtils.DynamicFilter{Column: "dp.KSM", Operator: queryUtils.OpNotNull})

	// filtering search results
	if search != "" {
		searchFilters := []queryUtils.DynamicFilter{
			{Column: "dp.Nama_depan", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "dp.NIP", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "dp.Nama_belakang", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
			{Column: "dk.Nama_ksm", Operator: queryUtils.OpILike, Value: "%" + search + "%"},
		}

		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: searchFilters, LogicOp: "OR"})
	}

	if len(baseFilter) > 0 {
		query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: baseFilter, LogicOp: "AND"})
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		// log.Fatalf("unable to connect db %s", err)
		return result, err
	}

	// query count
	countData, err := r.queryBuilder.ExecuteCount(c, dbconn, query)
	if err != nil {
		log.Printf("Unable to execute query count : %s ", err)
		return result, err
	}
	result.Paging.Limit = limit
	result.Paging.Offset = offset
	result.Paging.Total = int(countData)
	result.Paging.CalculatePagingInfo()

	// query data
	queryData := query
	queryData.Limit = limit
	queryData.Offset = offset
	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, queryData, &result.Data)
	if err != nil {
		// log.Fatalf("unable to execute query %s", err)
		return result, err
	}

	return result, nil
}

func (r dokterRepo) GetDokterById(c *gin.Context, id string) (DokterModel, error) {
	var resultQuery []DokterModel
	var result DokterModel

	// base query
	query := baseSelectQuery()

	// LIMIT 1
	query.Limit = 1

	// base filtering
	var baseFilter []queryUtils.DynamicFilter
	baseFilter = append(baseFilter, queryUtils.DynamicFilter{Column: "dp.KSM", Operator: queryUtils.OpNotNull})

	// filter by id
	baseFilter = append(baseFilter, queryUtils.DynamicFilter{Column: "dp.id", Operator: queryUtils.OpEqual, Value: id})

	query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: baseFilter, LogicOp: "AND"})

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		// log.Fatalf("unable to connect db %s", err) // TODO : handling error
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &resultQuery)
	if err != nil {
		// log.Fatalf("unable to execute query %s", err)
		return result, err
	}

	if len(resultQuery) == 0 {
		notFoundError := errors.New("doctor not found")
		return result, notFoundError
	}

	return resultQuery[0], nil
}