package integration

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

type ClinicalImppressionInterface interface {
	// Define methods for ClinicalImpressionInterface
	CreateClinicalImpression(req model.ClinicalImpressionRequest) (map[string]interface{}, error)
	UpdateClinicalImpression(req model.ClinicalImpressionRequest) (map[string]interface{}, error)
	GetClinicalImpressionByPatient(id string) (map[string]interface{}, error)
	HandleCheckClinicalImpression(id string) ([]string, bool, error)
}

type ClinicalImpressionRepository struct {
	akses *model.Akses
}

// GetClinicalImpressionByPatient implements ClinicalImppressionInterface.
func (c *ClinicalImpressionRepository) GetClinicalImpressionByPatient(id string) (map[string]interface{}, error) {
	var data map[string]interface{}
	url := c.akses.BaseUrl + "/ClinicalImpression?subject=" + id
	method := "GET"

	client := &http.Client{}
	request, err := http.NewRequest(method, url, nil)
	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)
	}
	request.Header.Add("Authorization", "Bearer "+token.AccessToken)
	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
}

// HandleCheckClinicalImpression implements ClinicalImppressionInterface.
func (c *ClinicalImpressionRepository) HandleCheckClinicalImpression(id string) ([]string, bool, error) {
	clinical, err := c.GetClinicalImpressionByPatient(id)
	if err != nil {
		return nil, false, err
	}
	var ids []string
	if entries, ok := clinical["entry"].([]interface{}); ok && len(entries) != 0 {
		if entries, ok := (clinical)["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
}

// CreateClinicalImpression implements ClinicalImppressionInterface.
func (c *ClinicalImpressionRepository) CreateClinicalImpression(req model.ClinicalImpressionRequest) (map[string]interface{}, error) {
	var (
		data map[string]interface{}
	)
	req.ResourceType = constant.ClinicalImpressionResourceType

	// Setup Patient
	var patient string
	if req.Subject.Reference != "" {
		patientInterface := NewPatientRepo(c.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 Encounter
	if patient != "" {
		encounterInterface := NewEncounterRepo(c.akses)
		encounterId, encounterExist, err := encounterInterface.HandleCheckEncounter(patient)
		if err != nil {
			return nil, err
		}
		if encounterExist {
			req.Encounter.Reference = "Encounter/" + encounterId
		} else {
			return nil, errors.New("encounter not found")
		}
	}
	// Setup Practitioner
	// if req.Assessor.Reference != "" {
	// 	practitionerInterface := NewPracticionerRepo(c.akses)
	// 	practitionerId, _, err := practitionerInterface.HandleCheckPartitioner(req.Assessor.Reference)
	// 	if err != nil {
	// 		return nil, err
	// 	}
	// 	if practitionerId != "" {
	// 		req.Assessor.Reference = "Practitioner/" + practitionerId
	// 	} else {
	// 		return nil, errors.New("practitioner not found")
	// 	}
	// }

	if len(req.Investigation) > 0 {
		//Setup Condition
		if patient != "" {
			conditionInterface := NewConditionRepo(c.akses)
			conditionId, conditionExist, err := conditionInterface.HandleCheckCondition(patient)
			if err != nil {
				return nil, err
			}
			req.Problem = append(req.Problem, model.Reference{
				Reference: "Condition/" + conditionId,
			})
			if !conditionExist {
				return nil, errors.New("condition not found")
			}
		}

		//Setup Observation
		if patient != "" {
			observationInterface := NewObservationRepo(c.akses)
			observationId, observationExist, err := observationInterface.HandleCheckObservation(patient)
			if err != nil {
				return nil, err
			}
			for _, id := range observationId {
				req.Investigation = append(req.Investigation, model.Investigation{
					Item: []model.InvestigationItem{
						{Reference: "Observation/" + id},
					},
				})
			}

			if !observationExist {
				return nil, errors.New("observation not found")
			}
		}
	}

	url := c.akses.BaseUrl + "/ClinicalImpression"
	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:     c.akses.ClientId,
		ClientSecret: c.akses.ClientSecret,
	}
	OauthInterface := NewOauthRequestRepo(c.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", "application/json")

	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
}

func (c *ClinicalImpressionRepository) UpdateClinicalImpression(req model.ClinicalImpressionRequest) (map[string]interface{}, error) {
	req.ResourceType = constant.ClinicalImpressionResourceType

	// Setup Patient
	var patient string
	if req.Subject.Reference != "" {
		patientInterface := NewPatientRepo(c.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 Encounter
	if patient != "" {
		encounterInterface := NewEncounterRepo(c.akses)
		encounterId, encounterExist, err := encounterInterface.HandleCheckEncounter(patient)
		if err != nil {
			return nil, err
		}
		if encounterExist {
			req.Encounter.Reference = "Encounter/" + encounterId
		} else {
			return nil, errors.New("encounter not found")
		}
	}
	// Setup Practitioner
	if req.Assessor.Reference != "" {
		practitionerInterface := NewPracticionerRepo(c.akses)
		practitionerId, _, err := practitionerInterface.HandleCheckPartitioner(req.Assessor.Reference)
		if err != nil {
			return nil, err
		}
		if practitionerId != "" {
			req.Assessor.Reference = "Practitioner/" + practitionerId
		} else {
			return nil, errors.New("practitioner not found")
		}

		//Setup Condition
		if patient != "" {
			conditionInterface := NewConditionRepo(c.akses)
			conditionId, conditionExist, err := conditionInterface.HandleCheckCondition(patient)
			if err != nil {
				return nil, err
			}
			req.Problem = append(req.Problem, model.Reference{
				Reference: "Condition/" + conditionId,
			})
			if !conditionExist {
				return nil, errors.New("condition not found")
			}
		}

		//Setup Observation
		if patient != "" {
			observationInterface := NewObservationRepo(c.akses)
			observationId, observationExist, err := observationInterface.HandleCheckObservation(patient)
			if err != nil {
				return nil, err
			}
			for _, id := range observationId {
				req.Investigation = append(req.Investigation, model.Investigation{
					Item: []model.InvestigationItem{
						{Reference: "Observation/" + id},
					},
				})
			}

			if !observationExist {
				return nil, errors.New("observation not found")
			}
		}
	}

	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("/ClinicalImpression/%s", req.Id)
	return httputil.DoRequest(httputil.RequestOption{
		Method:      "PUT",
		URL:         url,
		Body:        req,
		BearerToken: token.AccessToken,
	})
}

func NewClinicalImpressionRepo(akses *model.Akses) ClinicalImppressionInterface {
	return &ClinicalImpressionRepository{akses: akses}
}