package integration

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

type EncounterInterface interface {
	// Define methods for encounter integration
	CreateEncounter(req model.EncounterRequest) (map[string]interface{}, error)
	GetEncounterByPatient(id string) (map[string]interface{}, error)
	HandleCheckEncounter(patientID string) (string, bool, error)
	UpdateEncounter(req model.EncounterUpdateRequest) (map[string]interface{}, error)
}

type EncounterRepository struct {
	akses *model.Akses
}

// HandleCheckEncounter implements EncounterInterface.
func (e *EncounterRepository) HandleCheckEncounter(patientID string) (string, bool, error) {
	encounter, err := e.GetEncounterByPatient(patientID)
	if err != nil {
		return "", false, err
	}

	// You can process 'encounter' here if needed
	if entries, ok := encounter["entry"].([]interface{}); ok && len(entries) != 0 {
		if entries, ok := (encounter)["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, true, nil
					}
				}
			}
		}
		return "", true, nil
	}

	return "", false, nil
}

// GetEncounterByPatient implements EncounterInterface.
func (e *EncounterRepository) GetEncounterByPatient(id string) (map[string]interface{}, error) {
	var (
		data *map[string]interface{}
	)

	url := e.akses.BaseUrl + "/Encounter?subject=" + id
	method := "GET"

	client := &http.Client{}
	request, err := http.NewRequest(method, url, nil)
	if err != nil {
		return nil, err
	}
	oauth := model.OauthRequest{
		ClientId:     e.akses.ClientId,
		ClientSecret: e.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(e.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)
	res, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()

	if res.StatusCode != http.StatusOK {
		return nil, errors.New("failed to get encounter by patient: " + res.Status)
	}
	err = json.NewDecoder(res.Body).Decode(&data)
	if err != nil {
		return nil, err
	}
	if data == nil {
		return nil, errors.New("no encounter found for patient")
	}
	return *data, nil
}

func NewEncounterRepo(akses *model.Akses) EncounterInterface {
	return &EncounterRepository{akses: akses}
}

// CreateEncounter implements EncounterInterface.
func (e *EncounterRepository) CreateEncounter(req model.EncounterRequest) (map[string]interface{}, error) {
	var (
		data *map[string]interface{}
	)
	req.ResourceType = constant.EncounterResourceType
	req.Identifier = append(req.Identifier, model.IdentifierEncounter{
		System: "http://sys-ids.kemkes.go.id/encounter/" + os.Getenv("ORGANIZATION_ID"),
		Value:  os.Getenv("ORGANIZATION_ID"),
	})

	req.ServiceProvider.Reference = "Organization/" + os.Getenv("ORGANIZATION_ID")

	url := e.akses.BaseUrl + "/Encounter"
	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
	}
	oauth := model.OauthRequest{
		ClientId:     e.akses.ClientId,
		ClientSecret: e.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(e.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
}

// UpdateEncounter implements EncounterInterface.
func (e *EncounterRepository) UpdateEncounter(req model.EncounterUpdateRequest) (map[string]interface{}, error) {
	oauth := model.OauthRequest{
		ClientId:     e.akses.ClientId,
		ClientSecret: e.akses.ClientSecret,
	}
	token, err := NewOauthRequestRepo(e.akses).GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token == nil {
		return nil, errors.New(constant.ErrGenerateToken)
	}

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