package generatefile

import (
	"encoding/json"
	"errors"

	evs "simrs-vx/internal/domain/bpjs-entities/vclaim-sep"
	evscl "simrs-vx/internal/domain/bpjs-entities/vclaim-sep-control-letter"
	egc "simrs-vx/internal/domain/main-entities/general-consent"

	uvs "simrs-vx/internal/use-case/bpjs-use-case/vclaim-sep"
	uvscl "simrs-vx/internal/use-case/bpjs-use-case/vclaim-sep-control-letter"
	ugc "simrs-vx/internal/use-case/main-use-case/general-consent"

	pc "simrs-vx/pkg/conv-helper"
	pl "simrs-vx/pkg/logger"
	pu "simrs-vx/pkg/use-case-helper"

	dg "github.com/karincake/apem/db-gorm-pg"
	d "github.com/karincake/dodol"

	erc "simrs-vx/internal/domain/references/common"
	ere "simrs-vx/internal/domain/references/encounter"
)

const source = "generate-file"

func Generate(input GenerateDto) (*d.Data, error) {
	event := pl.Event{
		Feature: "Generate",
		Source:  source,
	}

	var response ResponseDto

	// Start log
	pl.SetLogInfo(&event, input, "started", "create")

	switch input.Type_Code {
	// general-consent
	case ere.DTCGC:
		// get value from general consent by ref_id
		gc, err := ugc.ReadDetailData(egc.ReadDetailDto{Id: uint(*pc.StringToUint64(*input.Ref_Id))}, &event)
		if err != nil {
			return nil, err
		}

		if gc.FileUrl != nil {
			if err := removeFile(string(input.EntityType_Code), *gc.FileUrl); err != nil {
				return nil, err
			}
		}

		// map template data
		templateData := GeneralConsentPDF{}
		if gc.Value != nil {
			err := json.Unmarshal([]byte(*gc.Value), &templateData)
			if err != nil {
				event.ErrInfo = pl.ErrorInfo{
					Code:   "data-unmarshal-fail",
					Detail: err.Error(),
					Raw:    err,
				}
				return nil, err
			}
		} else {
			return nil, errors.New("no value in this general consent")
		}

		input.FormatType = erc.DFTCPDF
		input.TemplateName = TDNGC
		input.Encounter_Id = gc.Encounter_Id
		templateData.Date = pu.FormatIndonesianDate(gc.CreatedAt)

		// generate file
		urlPub, err := generateFile(input, templateData)
		if err != nil {
			return nil, err
		}

		gc.FileUrl = &urlPub
		if err := dg.I.Save(&gc).Error; err != nil {
			return nil, err
		}

		response = ResponseDto{
			FileUrl: urlPub,
		}

	// control-letter
	case ere.DTCVSCL:
		// get value from control letter by ref_id
		cl, err := uvscl.ReadDetailData(evscl.ReadDetailDto{Number: input.Ref_Id}, &event)
		if err != nil {
			if !pu.IsDataNotFoundError(err) {
				return nil, err
			}
		}

		if cl != nil && cl.FileUrl != nil {
			if err := removeFile(string(input.EntityType_Code), *cl.FileUrl); err != nil {
				return nil, err
			}
		}

		// map template data
		clData := VclaimControlLetter{}
		if input.Data != nil {
			err := json.Unmarshal([]byte(*input.Data), &clData)
			if err != nil {
				event.ErrInfo = pl.ErrorInfo{
					Code:   "data-unmarshal-fail",
					Detail: err.Error(),
					Raw:    err,
				}
				return nil, err
			}
		} else {
			return nil, errors.New("there is no data to be used")
		}

		if cl == nil {
			createCL := evscl.CreateDto{
				VclaimSep_Number: &clData.VclaimSep.Number,
				Number:           &clData.Number,
				Value:            input.Data,
			}
			if cl, err = uvscl.CreateData(createCL, &event); err != nil {
				return nil, err
			}

		}
		// get encounter id by vclaim sep number
		vs, err := uvs.ReadDetailData(evs.ReadDetailDto{Number: &clData.VclaimSep.Number}, &event)
		if err != nil {
			return nil, err
		}

		input.FormatType = erc.DFTCPDF
		input.TemplateName = TDNCL
		input.Encounter_Id = vs.Encounter_Id

		templateData := clData.generateTemplateData()
		// generate file
		urlPub, err := generateFile(input, templateData)
		if err != nil {
			return nil, err
		}

		cl.FileUrl = &urlPub
		if err := dg.I.Save(&cl).Error; err != nil {
			return nil, err
		}

		response = ResponseDto{
			FileUrl: urlPub,
		}

	default:
		return nil, errors.New("invalid type code")
	}

	return &d.Data{
		Meta: d.II{
			"source":    source,
			"structure": "single-data",
			"status":    "created",
		},
		Data: response,
	}, nil
}