/*
DESCRIPTION:
Any functions that are used internally by the use-case
*/
package soapi

import (
	"errors"
	pl "simrs-vx/pkg/logger"

	dg "github.com/karincake/apem/db-gorm-pg"
	"gorm.io/gorm"

	ere "simrs-vx/internal/domain/references/encounter"

	ecpl "simrs-vx/internal/domain/main-entities/chemo-plan"
	ecp "simrs-vx/internal/domain/main-entities/chemo-protocol"
	ee "simrs-vx/internal/domain/main-entities/encounter"
	e "simrs-vx/internal/domain/main-entities/soapi"
)

func setData[T *e.CreateDto | *e.UpdateDto](input T, data *e.Soapi) {
	var inputSrc *e.CreateDto
	if inputT, ok := any(input).(*e.CreateDto); ok {
		inputSrc = inputT
	} else {
		inputTemp := any(input).(*e.UpdateDto)
		inputSrc = &inputTemp.CreateDto
	}

	data.Encounter_Id = inputSrc.Encounter_Id
	data.Employee_Id = inputSrc.AuthInfo.Employee_Id
	data.Time = inputSrc.Time
	data.TypeCode = inputSrc.TypeCode
	data.Value = inputSrc.Value
}

func setBulkData(input []e.CreateDto, encounterId uint) []e.Soapi {
	var data []e.Soapi

	for _, v := range input {
		data = append(data, e.Soapi{
			Encounter_Id: &encounterId,
			Employee_Id:  v.Employee_Id,
			Time:         v.Time,
			TypeCode:     v.TypeCode,
			Value:        v.Value,
		})
	}

	return data
}

func validateIfEncounterIsChemo(encounterId uint, method string, event *pl.Event) (*ecpl.ChemoPlan, error) {
	// get encounter
	enc, err := getEncounter(encounterId, event)
	if err != nil {
		return nil, err
	}

	// Encounter must be Ambulatory and NOT Rehab
	a := enc.Ambulatory
	if a == nil || a.Class_Code == ere.ACCRehab {
		return nil, nil
	}

	// get chemo protocol
	chemo, err := getChemo(*enc.Patient_Id, enc.Id, event)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, pl.SetLogError(event, nil)
	}

	if chemo.ChemoPlans == nil || len(*chemo.ChemoPlans) == 0 {
		return nil, nil
	}

	// Return the first chemo plan
	return &(*chemo.ChemoPlans)[0], nil
}

func getEncounter(encounterId uint, event *pl.Event) (*ee.Encounter, error) {
	pl.SetLogInfo(event, nil, "started", "getEncounter")
	data := ee.Encounter{}

	var tx = dg.I

	err := tx.Model(&ee.Encounter{}).
		Joins(`LEFT JOIN "Ambulatory" a ON a."Encounter_Id" = "Encounter"."Id"`).
		Where(`"Encounter"."Id" = ?`, encounterId).
		Where(`"Encounter"."Class_Code" = ?`, ere.ECAmbulatory).
		Preload("Ambulatory").
		First(&data).Error

	if err != nil {
		return nil, err
	}

	pl.SetLogInfo(event, nil, "complete")
	return &data, nil
}

func getChemo(patientId, encounterId uint, event *pl.Event) (*ecp.ChemoProtocol, error) {
	pl.SetLogInfo(event, nil, "started", "getChemo")
	data := ecp.ChemoProtocol{}

	var tx = dg.I

	tx = tx.Model(&ecp.ChemoProtocol{}).
		Joins(`LEFT JOIN "ChemoPlan" cp ON cp."Protocol_Id" = "ChemoProtocol"."Id"`).
		Where(`"ChemoProtocol"."Patient_Id" = ?`, patientId).
		Preload("ChemoPlans", func(db *gorm.DB) *gorm.DB {
			return db.
				Where(`"Encounter_Id" = ?`, encounterId)
		}).
		First(&data)

	if err := tx.Error; err != nil {
		return nil, err
	}

	pl.SetLogInfo(event, nil, "complete")
	return &data, nil
}