package integration

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

type SpecimenInterface interface {
	CreateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error)
	GetSpecimenByPatient(id string) (map[string]interface{}, error)
	GetSpecimenByPatientCategory(id string, category string) (map[string]interface{}, error)
	HandleCheckSpecimen(id string) ([]string, bool, error)
	HandleCheckSpecimenCategory(id string, category string) ([]string, bool, error)
	UpdateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error)
}

type SpecimenRepository struct {
	akses *model.Akses
}

// GetSpecimenByPatientCategory implements SpecimenInterface.
func (s *SpecimenRepository) GetSpecimenByPatientCategory(id string, category string) (map[string]interface{}, error) {
	var data map[string]interface{}

	url := s.akses.BaseUrl + "/Specimen?subject=" + id + "&category=" + category
	method := "GET"

	client := &http.Client{}
	request, err := http.NewRequest(method, url, nil)
	if err != nil {
		return nil, err
	}

	oauth := model.OauthRequest{
		ClientId:     s.akses.ClientId,
		ClientSecret: s.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(s.akses)
	token, err := OauthInterface.GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token != nil {
		request.Header.Set("Authorization", "Bearer "+token.AccessToken)
	}
	request.Header.Set("Content-Type", 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
}

// HandleCheckSpecimenCategory implements SpecimenInterface.
func (s *SpecimenRepository) HandleCheckSpecimenCategory(id string, category string) ([]string, bool, error) {
	specimen, err := s.GetSpecimenByPatientCategory(id, category)
	if err != nil {
		return nil, false, err
	}
	var ids []string
	if entries, ok := specimen["entry"].([]interface{}); ok && len(entries) != 0 {
		if entries, ok := (specimen)["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)
						ids = append(ids, id)
						return ids, true, nil
					}
				}
			}
		}
		return nil, true, nil
	}

	return nil, false, nil
}

// CreateSpecimen implements SpecimenInterface.
func (s *SpecimenRepository) CreateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error) {
	var data map[string]interface{}

	req.ResourceType = constant.SpecimenResourceType
	// Setup Patient
	var patient string
	if req.Subject.Reference != "" {
		patientInterface := NewPatientRepo(s.akses)
		var err error
		patient, err = patientInterface.HandleCheckPatient(req.Subject.Reference)
		if err != nil {
			return nil, err
		}

		if patient == "" { // Belum ada di satu sehat
			return nil, errors.New("patient not found")
		} else {
			req.Subject.Reference = "Patient/" + patient
		}
	}

	// Setup Service Request
	err := s.setupServiceRequest(&req, patient)
	if err != nil {
		return nil, err
	}

	url := s.akses.BaseUrl + "/Specimen"
	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
	}

	request.Header.Set("Content-Type", "application/json")

	oauth := model.OauthRequest{
		ClientId:     s.akses.ClientId,
		ClientSecret: s.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(s.akses)
	token, err := OauthInterface.GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token != nil {
		request.Header.Set("Authorization", "Bearer "+token.AccessToken)
	}

	response, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()
	err = json.NewDecoder(response.Body).Decode(&data)
	if err != nil {
		return nil, err
	}
	if !isOperationOutcomeError(data) {
		// Setup Encounter
		if patient != "" {
			encounterInterface := NewEncounterRepo(s.akses)
			encounterId, encounterExist, err := encounterInterface.HandleCheckEncounter(patient)
			if err != nil {
				return nil, err
			}

			if encounterExist {
				data["encounter"] = map[string]interface{}{
					"reference": "Encounter/" + encounterId,
				}
			} else {
				return nil, errors.New("encounter not found")
			}
		}
	}

	return data, nil
}

// GetSpecimenByPatient implements SpecimenInterface.
func (s *SpecimenRepository) GetSpecimenByPatient(id string) (map[string]interface{}, error) {
	var data map[string]interface{}
	url := s.akses.BaseUrl + "/Specimen?subject=" + id
	method := "GET"
	client := &http.Client{}
	request, err := http.NewRequest(method, url, nil)
	if err != nil {
		return nil, err
	}
	oauth := model.OauthRequest{
		ClientId:     s.akses.ClientId,
		ClientSecret: s.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(s.akses)
	token, err := OauthInterface.GenerateToken(oauth)
	if err != nil {
		return nil, err
	}
	if token != nil {
		request.Header.Set("Authorization", "Bearer "+token.AccessToken)
	}

	response, err := client.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()
	err = json.NewDecoder(response.Body).Decode(&data)
	if err != nil {
		return nil, err
	}

	return data, nil
}

// isOperationOutcomeError returns true when the response is an OperationOutcome
// with at least one issue that includes diagnostics or details.text.
func isOperationOutcomeError(resp map[string]interface{}) bool {
	if resp == nil {
		return false
	}
	if rt, ok := resp["resourceType"].(string); !ok || rt != "OperationOutcome" {
		return false
	}
	issues, ok := resp["issue"].([]interface{})
	if !ok || len(issues) == 0 {
		return false
	}
	for _, it := range issues {
		if m, ok := it.(map[string]interface{}); ok {
			if diag, ok := m["diagnostics"].(string); ok && diag != "" {
				return true
			}
			if details, ok := m["details"].(map[string]interface{}); ok {
				if txt, ok := details["text"].(string); ok && txt != "" {
					return true
				}
			}
		}
	}
	return false
}

func (s *SpecimenRepository) setupServiceRequest(req *model.SpecimenRequest, patient string) error {
	if patient == "" {
		return nil
	}
	serviceReq := NewServiceRequestRepository(s.akses)
	ids, _, err := serviceReq.HandleCheckServiceRequest(patient)
	if err != nil {
		return err
	}
	if len(ids) > 0 {
		req.Request = []model.Reference{
			{
				Reference: "ServiceRequest/" + ids[0],
			},
		}
	}
	return nil
}

// HandleCheckSpecimen implements SpecimenInterface.
func (s *SpecimenRepository) HandleCheckSpecimen(id string) ([]string, bool, error) {
	specimen, err := s.GetSpecimenByPatient(id)
	if err != nil {
		return nil, false, err
	}

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

	return nil, false, nil
}

func (s *SpecimenRepository) UpdateSpecimen(req model.SpecimenRequest) (map[string]interface{}, error) {
	req.ResourceType = constant.SpecimenResourceType
	// Setup Patient
	var patient string
	if req.Subject.Reference != "" {
		patientInterface := NewPatientRepo(s.akses)
		var err error
		patient, err = patientInterface.HandleCheckPatient(req.Subject.Reference)
		if err != nil {
			return nil, err
		}

		if patient == "" { // Belum ada di satu sehat
			return nil, errors.New("patient not found")
		} else {
			req.Subject.Reference = "Patient/" + patient
		}
	}

	// Setup Service Request
	err := s.setupServiceRequest(&req, patient)
	if err != nil {
		return nil, err
	}

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

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

func NewSpecimenRepository(akses *model.Akses) SpecimenInterface {
	return &SpecimenRepository{akses: akses}
}