package generatefile

import (
	"errors"
	"fmt"
	"mime"
	"path/filepath"
	"time"

	erc "simrs-vx/internal/domain/references/common"
	docscfg "simrs-vx/internal/infra/docs-cfg"
	pc "simrs-vx/pkg/conv-helper"
	pf "simrs-vx/pkg/file-helper"
	pm "simrs-vx/pkg/minio-helper"
	pp "simrs-vx/pkg/pdf-helper"
	pu "simrs-vx/pkg/use-case-helper"
)

// generate temporary file, upload to minio, generate public url, delete temporary file
func generateFile(input GenerateDto, templateData any) (string, error) {
	newPath, err := pf.PathToSaveFile(fmt.Sprintf("./temporary/%s", input.EntityType_Code))
	if err != nil {
		return "", err
	}

	fPath := fmt.Sprintf("%s/%s-%s.%s", newPath, input.Type_Code, time.Now().Format("20060102150405"), input.FormatType)

	templatePath := docscfg.O.GetPath() + string(input.TemplateName)

	switch input.FormatType {
	case erc.DFTCPDF:
		if err := generatePDF(GeneratePDFdto{
			TemplatePath: templatePath,
			TemplateData: templateData,
			PdfPath:      fPath,
		}); err != nil {
			return "", err
		}
	case erc.DFTCTXLSX:
		// TODO: generate xlsx
	case erc.DFTCTCSV:
		// TODO: generate csv
	default:
		return "", errors.New("invalid format type")
	}

	bucketName := input.EntityType_Code

	objectName := fmt.Sprintf("%s/%s-%d.%s", *pc.UintToString(input.Encounter_Id), input.Type_Code, time.Now().UnixNano(), input.FormatType)
	pdfUpload := pm.UploadPathInput{
		BucketName:  string(bucketName),
		Name:        objectName,
		Path:        fPath,
		ContentType: mime.TypeByExtension(filepath.Ext(fPath)),
	}

	// create bucket if not exist, create object in bucket
	info, err := pm.I.FPutObject(pdfUpload)
	if err != nil {
		return "", err
	}

	// generate public url
	urlPub := pm.I.GenerateUrl(info.Bucket, info.Key)
	if err := pf.DeleteFolder(fPath); err != nil {
		return "", err
	}

	return urlPub, nil
}

func generatePDF(input GeneratePDFdto) error {
	// parse template data into html template
	r := pp.NewRequestPdf("")
	if err := r.ParseTemplate(input.TemplatePath, input.TemplateData); err == nil {
		_, err := r.GenerateByCommand(input.PdfPath, input.TemplatePath)
		if err != nil {
			return errors.New("generate pdf by command error : " + err.Error())
		}
	} else {
		return errors.New("parse template error : " + err.Error())
	}

	return nil
}

func removeFile(bucket, fileUrl string) error {
	fPath := pu.GetLastTwoPathSegments(fileUrl)
	err := pm.I.RemoveObject(bucket, fPath)
	if err != nil {
		return err
	}
	return nil
}