package upload

import (
	"errors"
	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"
	"gorm.io/gorm"

	eru "simrs-vx/internal/domain/references/upload"

	e "simrs-vx/internal/domain/main-entities/upload"
)

const source = "upload"

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

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

	var data interface{}
	err := dg.I.Transaction(func(tx *gorm.DB) error {
		mwRunner := newMiddlewareRunner(&event, tx)
		mwRunner.setMwType(pu.MWTPre)

		// Run pre-middleware
		err := mwRunner.RunCreateMiddleware(createPreMw, &input, &data)
		if err != nil {
			return err
		}

		// validate entityType_Code and Type_Code
		valid, msg := eru.IsValidUploadCode(input.EntityType_Code, input.Type_Code)
		if !valid {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "invalid-code",
				Detail: msg,
				Raw:    errors.New(msg),
			}
			return pl.SetLogError(&event, input)
		}

		// upload file
		input.FilePath, err = uploadAndGenerateFileUrl(input, &event)
		if err != nil {
			return err
		}

		if input.EntityType_Code == eru.ETCEncounter {
			data, err = setEncounterDocument(input, &event, tx)
			if err != nil {
				return err
			}

		} else if input.EntityType_Code == eru.ETCPerson {
			data, err = setPersonAttachment(input, &event, tx)
		}

		mwRunner.setMwType(pu.MWTPost)
		// Run post-middleware
		if err := mwRunner.RunCreateMiddleware(createPostMw, &input, &data); err != nil {
			return err
		}

		pl.SetLogInfo(&event, nil, "complete")

		return nil
	})

	if err != nil {
		return nil, err
	}

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