package integration

import (
	"errors"
	"fmt"
	"satusehat-rssa/internal/constant"
	"satusehat-rssa/internal/model"
	"satusehat-rssa/pkg/common"
	"satusehat-rssa/pkg/httputil"
)

type MedicationStatementInterface interface {
	// Define methods for MedicationStatementInterface
	CreateMedicationStatement(req model.MedicationStatementRequest) (map[string]interface{}, error)
	UpdateMedicationStatement(req model.MedicationStatementRequest) (map[string]interface{}, error)
}

type MedicationStatementRepository struct {
	// Define fields for MedicationStatementRepository
	akses *model.Akses
}

func NewMedicationStatementRepo(akses *model.Akses) MedicationStatementInterface {
	return &MedicationStatementRepository{
		akses: akses,
	}
}

// CreateMedicationStatement implements MedicationStatementInterface.
func (c *MedicationStatementRepository) CreateMedicationStatement(req model.MedicationStatementRequest) (map[string]interface{}, error) {
	req.ResourceType = constant.MedicationStatementResourceType

	// inject identifier to contained
	if len(req.Contained) > 0 {
		for k, c := range req.Contained {
			identifier := common.GetIdentifier("medication")
			identifier.Value = c.ID
			req.Contained[k].Identifier = append(req.Contained[k].Identifier, identifier)
		}
	}

	patient, err := c.setupPatient(&req)
	if err != nil {
		return nil, err
	}

	err = c.setupEncounter(&req, patient)
	if err != nil {
		return nil, err
	}

	err = c.setupSource(&req)
	if err != nil {
		return nil, err
	}

	oauth := model.OauthRequest{
		ClientId:     c.akses.ClientId,
		ClientSecret: c.akses.ClientSecret,
	}
	token, err := NewOauthRequestRepo(c.akses).GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token == nil {
		return nil, errors.New(constant.ErrGenerateToken)
	}

	url := c.akses.BaseUrl + "/MedicationStatement"
	return httputil.DoRequest(httputil.RequestOption{
		Method:      "POST",
		URL:         url,
		Body:        req,
		BearerToken: token.AccessToken,
		Headers:     httputil.DefaultFHIRHeaders(),
	})
}

func (c *MedicationStatementRepository) UpdateMedicationStatement(req model.MedicationStatementRequest) (map[string]interface{}, error) {
	req.ResourceType = constant.MedicationStatementResourceType

	// inject identifier to contained
	if len(req.Contained) > 0 {
		for k, c := range req.Contained {
			identifier := common.GetIdentifier("medication")
			identifier.Value = c.ID
			req.Contained[k].Identifier = append(req.Contained[k].Identifier, identifier)
		}
	}

	patient, err := c.setupPatient(&req)
	if err != nil {
		return nil, err
	}

	err = c.setupEncounter(&req, patient)
	if err != nil {
		return nil, err
	}

	err = c.setupSource(&req)
	if err != nil {
		return nil, err
	}

	oauth := model.OauthRequest{
		ClientId:     c.akses.ClientId,
		ClientSecret: c.akses.ClientSecret,
	}
	token, err := NewOauthRequestRepo(c.akses).GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token == nil {
		return nil, errors.New(constant.ErrGenerateToken)
	}

	url := c.akses.BaseUrl + fmt.Sprintf("/MedicationStatement/%s", req.Id)
	return httputil.DoRequest(httputil.RequestOption{
		Method:      "PUT",
		URL:         url,
		Body:        req,
		BearerToken: token.AccessToken,
		Headers:     httputil.DefaultFHIRHeaders(),
	})
}

func (c *MedicationStatementRepository) setupPatient(req *model.MedicationStatementRequest) (string, error) {
	if req.Subject.Reference == "" {
		return "", nil
	}
	patientInterface := NewPatientRepo(c.akses)
	patient, err := patientInterface.HandleCheckPatient(req.Subject.Reference)
	if err != nil {
		return "", err
	}

	if patient != "" {
		req.Subject.Reference = "Patient/" + patient
	}
	return patient, nil
}

func (c *MedicationStatementRepository) setupSource(req *model.MedicationStatementRequest) error {
	if req.InformationSource.Reference == "" {
		return nil
	}
	patientInterface := NewPatientRepo(c.akses)
	patient, err := patientInterface.HandleCheckPatient(req.InformationSource.Reference)
	if err != nil {
		return err
	}

	if patient != "" {
		req.InformationSource.Reference = "Patient/" + patient
	}
	return nil
}

func (c *MedicationStatementRepository) setupEncounter(req *model.MedicationStatementRequest, patient string) error {
	if patient == "" {
		return nil
	}
	encounterInterface := NewEncounterRepo(c.akses)
	encounterId, encounterExist, err := encounterInterface.HandleCheckEncounter(patient)
	if err != nil {
		return err
	}
	if encounterExist {
		req.Context.Reference = "Encounter/" + encounterId
	}
	return nil
}