package chemo_protocol

import (
	"errors"
	"strconv"

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

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

	"gorm.io/gorm"

	erc "simrs-vx/internal/domain/references/common"

	ec "simrs-vx/internal/domain/main-entities/chemo"
	e "simrs-vx/internal/domain/main-entities/chemo-protocol"
	ee "simrs-vx/internal/domain/main-entities/encounter"

	uc "simrs-vx/internal/use-case/main-use-case/chemo"
	ucp "simrs-vx/internal/use-case/main-use-case/chemo-plan"
	ue "simrs-vx/internal/use-case/main-use-case/encounter"
)

const source = "chemo-protocol"

func Create(input e.CreateDto) (*d.Data, error) {
	data := e.ChemoProtocol{}
	var err error

	event := pl.Event{
		Feature: "Create",
		Source:  source,
	}

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

	if input.Patient_Id == nil {
		// get encounter
		dataEncounter, err := ue.ReadDetailData(ee.ReadDetailDto{Id: *input.Encounter_Id}, &event)
		if err != nil {
			return nil, err
		}

		input.Patient_Id = dataEncounter.Patient_Id
		input.Status_Code = erc.DVCNew
	}

	// get chemo
	dataChemo, err := uc.ReadDetailData(ec.ReadDetailDto{Id: *input.Chemo_Id}, &event)
	if err != nil {
		return nil, err
	}

	if dataChemo.Status_Code != erc.DVCVerified {
		event.Status = "failed"
		event.ErrInfo = pl.ErrorInfo{
			Code:   "data-validation-fail",
			Detail: "chemo must be verified",
		}
		return nil, pl.SetLogError(&event, input)
	}

	err = dg.I.Transaction(func(tx *gorm.DB) error {
		// Insert Chemo-Protocol
		if resData, err := CreateData(input, &event, tx); err != nil {
			return err
		} else {
			data = *resData
		}

		// Insert Chemo-Plans
		input.Id = &data.Id
		if data.ChemoPlans, err = ucp.CreateData(&input, &event, tx); 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: data.ToResponse(),
	}, nil
}

func ReadList(input e.ReadListDto) (*d.Data, error) {
	var data *e.ChemoProtocol
	var dataList []e.ChemoProtocol
	var metaList *e.MetaDto
	var err error

	event := pl.Event{
		Feature: "ReadList",
		Source:  source,
	}

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

	if input.Patient_Id == nil {
		event.Status = "failed"
		event.ErrInfo = pl.ErrorInfo{
			Code:   "data-validation-fail",
			Detail: "patient-id is required",
		}
		return nil, pl.SetLogError(&event, input)
	}

	err = dg.I.Transaction(func(tx *gorm.DB) error {
		mwRunner := newMiddlewareRunner(&event, tx)
		mwRunner.setMwType(pu.MWTPre)
		// Run pre-middleware
		if err := mwRunner.RunReadListMiddleware(readListPreMw, &input, data); err != nil {
			return err
		}

		if dataList, metaList, err = ReadListData(input, &event, tx); err != nil {
			return err
		}

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

		return nil
	})

	if err != nil {
		return nil, err
	}

	return &d.Data{
		Meta: d.IS{
			"source":              source,
			"structure":           "list-data",
			"status":              "fetched",
			"page_number":         strconv.Itoa(metaList.PageNumber),
			"page_size":           strconv.Itoa(metaList.PageSize),
			"record_totalCount":   strconv.Itoa(metaList.Count),
			"record_currentCount": strconv.Itoa(len(dataList)),
		},
		Data: e.ToResponseList(dataList),
	}, nil
}

func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
	var data *e.ChemoProtocol
	var err error

	event := pl.Event{
		Feature: "ReadDetail",
		Source:  source,
	}

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

	err = dg.I.Transaction(func(tx *gorm.DB) error {
		mwRunner := newMiddlewareRunner(&event, tx)
		mwRunner.setMwType(pu.MWTPre)
		// Run pre-middleware
		if err := mwRunner.RunReadDetailMiddleware(readDetailPreMw, &input, data); err != nil {
			return err
		}

		if data, err = ReadDetailData(input, &event, tx); err != nil {
			return err
		}

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

		return nil
	})

	if err != nil {
		return nil, err
	}

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

func Update(input e.UpdateDto) (*d.Data, error) {
	rdDto := e.ReadDetailDto{Id: input.Id}
	var data *e.ChemoProtocol
	var err error

	event := pl.Event{
		Feature: "Update",
		Source:  source,
	}

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

	err = dg.I.Transaction(func(tx *gorm.DB) error {
		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
			return err
		}

		mwRunner := newMiddlewareRunner(&event, tx)
		mwRunner.setMwType(pu.MWTPre)
		// Run pre-middleware
		if err := mwRunner.RunUpdateMiddleware(readDetailPreMw, &rdDto, data); err != nil {
			return err
		}

		if err := UpdateData(input, data, &event, tx); err != nil {
			return err
		}

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

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

		return nil
	})

	if err != nil {
		return nil, err
	}

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

}

func Delete(input e.DeleteDto) (*d.Data, error) {
	rdDto := e.ReadDetailDto{Id: input.Id}
	var data *e.ChemoProtocol
	var err error

	event := pl.Event{
		Feature: "Delete",
		Source:  source,
	}

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

	err = dg.I.Transaction(func(tx *gorm.DB) error {
		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
			return err
		}

		mwRunner := newMiddlewareRunner(&event, tx)
		mwRunner.setMwType(pu.MWTPre)
		// Run pre-middleware
		if err := mwRunner.RunDeleteMiddleware(readDetailPreMw, &rdDto, data); err != nil {
			return err
		}

		if err := DeleteData(data, &event, tx); err != nil {
			return err
		}

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

		return nil
	})

	if err != nil {
		return nil, err
	}

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

}

func Verify(input e.VerifyDto) (*d.Data, error) {
	rdDto := e.ReadDetailDto{Id: input.Id}
	var data *e.ChemoProtocol
	var err error

	event := pl.Event{
		Feature: "Verify",
		Source:  source,
	}

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

	err = dg.I.Transaction(func(tx *gorm.DB) error {
		pl.SetLogInfo(&event, rdDto, "started", "DBReadDetail")
		if data, err = ReadDetailData(rdDto, &event, tx); err != nil {
			return err
		}

		if data.Status_Code != erc.DVCNew {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-state-mismatch",
				Detail: "data is not new",
				Raw:    errors.New("data is not new"),
			}
			return pl.SetLogError(&event, input)
		}

		data.VerifiedAt = pu.GetTimeNow()
		data.Status_Code = erc.DVCVerified
		data.VerifiedBy_User_Id = &input.AuthInfo.User_Id

		err = tx.Save(&data).Error
		if err != nil {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-update-fail",
				Detail: "Database update failed",
				Raw:    err,
			}
			return pl.SetLogError(&event, input)
		}

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

		return nil
	})

	if err != nil {
	}

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