package integration

import (
	"bytes"
	"encoding/json"
	"errors"
	"net/http"
	"satusehat-rssa/internal/constant"
	"satusehat-rssa/internal/model"
)

type PatientInterface interface {
	// Define methods for PartientInterface
	CreataPatient(req model.PatientRequest) (*map[string]interface{}, error)
	GetPatientByNIK(identifier string) (*map[string]interface{}, error)
	HandleCheckPatient(nik string) (string, error)
}

type PatientRepository struct {
	akses *model.Akses
}

// HandleCheckPatient implements PatientInterface.
func (p *PatientRepository) HandleCheckPatient(nik string) (string, error) {
	nik = "https://fhir.kemkes.go.id/id/nik|" + nik
	patient, err := p.GetPatientByNIK(nik)
	if err != nil {
		return "", err
	}

	if entries, ok := (*patient)["entry"].([]interface{}); ok && len(entries) > 0 {
		if entryMap, ok := entries[0].(map[string]interface{}); ok {
			if resource, ok := entryMap["resource"].(map[string]interface{}); ok {
				if id, ok := resource["id"].(string); ok {
					//fmt.Println("resource.id:", id)
					return id, nil
				}
			}
		}
	}

	return "", nil
}

// CreataPatient implements PatientInterface.
func (p *PatientRepository) CreataPatient(req model.PatientRequest) (*map[string]interface{}, error) {
	var (
		data *map[string]interface{}
	)
	req.ResourceType = constant.PatientResourceType
	req.Meta = model.Meta{
		Profile: []string{constant.PatientProfile},
	}

	url := p.akses.BaseUrl + "/Patient"
	method := "POST"

	payload, err := json.Marshal(req)
	if err != nil {
		return nil, err
	}
	client := &http.Client{}
	request, err := http.NewRequest(method, url, bytes.NewBuffer(payload))
	if err != nil {
		return nil, err
	}
	// Assuming the access token is stored in a field of the akses struct
	oauth := model.OauthRequest{
		ClientId:     p.akses.ClientId,
		ClientSecret: p.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(p.akses)
	token, err := OauthInterface.GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token != nil {
		request.Header.Add("Authorization", "Bearer "+token.AccessToken)
	} else {
		return nil, errors.New(constant.ErrGenerateToken)
	}
	request.Header.Set("Content-Type", constant.ContentTypeFHIRJSON)
	request.Header.Set("Accept", constant.ContentTypeFHIRJSON)
	res, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return nil, err
	}
	return data, nil

}

// GetPatientByNIK implements PatientInterface.
func (p *PatientRepository) GetPatientByNIK(identifier string) (*map[string]interface{}, error) {
	var (
		data *map[string]interface{}
	)
	url := p.akses.BaseUrl + "/Patient?identifier=" + identifier
	method := "GET"
	client := &http.Client{}
	request, err := http.NewRequest(method, url, nil)
	if err != nil {
		return nil, err
	}
	// Assuming the access token is stored in a field of the akses struct
	oauth := model.OauthRequest{
		ClientId:     p.akses.ClientId,
		ClientSecret: p.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(p.akses)
	token, err := OauthInterface.GenerateToken(oauth)

	if err != nil {
		return nil, err
	}
	if token != nil {
		request.Header.Add("Authorization", "Bearer "+token.AccessToken)
	} else {
		return nil, errors.New(constant.ErrGenerateToken)
	}

	request.Header.Set("Content-Type", constant.ContentTypeFHIRJSON)
	request.Header.Set("Accept", constant.ContentTypeFHIRJSON)

	res, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return nil, err
	}
	return data, nil
}

// CreataPatient implements PartientInterface.
func NewPatientRepo(akses *model.Akses) PatientInterface {
	return &PatientRepository{akses: akses}
}