package unit

import (
	"fmt"
	e "simrs-vx/internal/domain/main-entities/unit"
	"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"
)

const source = "unit"

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

	setData(&input, &data)

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

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

	err := dg.I.Transaction(func(tx *gorm.DB) error {
		for i := range createPreMw {
			mwName := fmt.Sprintf("createPreMw[%d]", i)

			pl.SetLogInfo(&event, data, "started", mwName)

			if err := createPreMw[i](&input, &data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_PRE_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Pre-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, data)
			}

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

		pl.SetLogInfo(&event, data, "started", "DBCreate")
		_, err := CreateData(&data, tx)
		if err != nil {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-create-fail",
				Detail: "Database insert failed",
				Raw:    err,
			}
			return pl.SetLogError(event, data)
		}

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

		for i := range createPostMw {
			mwName := fmt.Sprintf("createPostMw[%d]", i)

			pl.SetLogInfo(&event, input, "started", mwName)
			if err := createPostMw[i](&input, &data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_POST_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Post-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, data)
			}
		}

		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.Unit
	var dataList []e.Unit
	var metaList *e.MetaDto
	var err error

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

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

	err = dg.I.Transaction(func(tx *gorm.DB) error {
		for i := range readListPreMw {
			mwName := fmt.Sprintf("readListPreMw[%d]", i)

			pl.SetLogInfo(&event, input, "started", mwName)

			if err := readListPreMw[i](&input, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_PRE_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Pre-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, input)
			}

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

		pl.SetLogInfo(&event, input, "started", "DBReadList")
		dataList, metaList, err = ReadListData(input, tx)
		if err != nil {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-read-list-fail",
				Detail: "Database read list failed",
				Raw:    err,
			}
			return pl.SetLogError(event, input)
		}

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

		for i := range readListPostMw {
			mwName := fmt.Sprintf("readListPostMw[%d]", i)

			pl.SetLogInfo(&event, input, "started", mwName)

			if err := readListPostMw[i](&input, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_POST_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Post-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, input)
			}

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

		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),
		},
		Data: e.ToResponseList(dataList),
	}, nil
}

func ReadDetail(input e.ReadDetailDto) (*d.Data, error) {
	var data *e.Unit
	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 {
		for i := range readDetailPreMw {
			mwName := fmt.Sprintf("readDetailPreMw[%d]", i)

			pl.SetLogInfo(&event, input, "started", mwName)

			if err := readDetailPreMw[i](&input, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_PRE_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Pre-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, input)
			}

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

		pl.SetLogInfo(&event, input, "started", "DBReadDetail")
		data, err = ReadDetailData(input, tx)
		if processedErr := pu.HandleReadError(err, &event, source, input.Id, data); processedErr != nil {
			return processedErr
		}

		for i := range readDetailPostMw {
			mwName := fmt.Sprintf("readDetailPostMw[%d]", i)

			pl.SetLogInfo(&event, data, "started", mwName)

			if err := readDetailPostMw[i](&input, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_POST_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Post-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, data)
			}

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

		return nil
	})

	if err != nil {
		return nil, err
	}

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

func Update(input e.UpdateDto) (*d.Data, error) {
	rdDto := e.ReadDetailDto{Id: input.Id}
	var data *e.Unit
	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")
		data, err = ReadDetailData(rdDto, tx)
		if processedErr := pu.HandleReadError(err, &event, source, input.Id, data); processedErr != nil {
			return processedErr
		}

		pl.SetLogInfo(&event, input, "started", "setUpdate")
		setData(&input, data)

		for i := range updatePreMw {
			mwName := fmt.Sprintf("updatePreMw[%d]", i)

			pl.SetLogInfo(&event, data, "started", mwName)

			if err := updatePreMw[i](&rdDto, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_PRE_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Pre-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, data)
			}

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

		pl.SetLogInfo(&event, data, "started", "DBUpdate")
		if err := UpdateData(*data, tx); err != nil {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-update-fail",
				Detail: "Database update failed",
				Raw:    err,
			}
			return pl.SetLogError(event, data)
		}

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

		for i := range updatePostMw {
			mwName := fmt.Sprintf("updatePostMw[%d]", i)

			pl.SetLogInfo(&event, data, "started", mwName)

			if err := updatePostMw[i](&rdDto, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_POST_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Post-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, data)
			}

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

		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.Unit
	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")
		data, err = ReadDetailData(rdDto, tx)
		if processedErr := pu.HandleReadError(err, &event, source, input.Id, data); processedErr != nil {
			return processedErr
		}

		for i := range deletePreMw {
			mwName := fmt.Sprintf("deletePreMw[%d]", i)

			pl.SetLogInfo(&event, data, "started", mwName)

			if err := deletePreMw[i](&rdDto, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_PRE_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Pre-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, data)
			}

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

		pl.SetLogInfo(&event, data, "started", "DBDelete")
		if err := DeleteData(data, tx); err != nil {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-delete-fail",
				Detail: "Database delete failed",
				Raw:    err,
			}
			return pl.SetLogError(event, data)
		}

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

		for i := range deletePostMw {
			mwName := fmt.Sprintf("deletePostMw[%d]", i)

			pl.SetLogInfo(&event, data, "started", mwName)

			if err := deletePostMw[i](&rdDto, data, tx); err != nil {
				event.Status = "failed"
				event.ErrInfo = pl.ErrorInfo{
					Code:   "MW_POST_FAILED", // TODO: add to lang json
					Detail: fmt.Sprintf("Post-middleware %s failed", mwName),
					Raw:    err,
				}
				return pl.SetLogError(event, data)
			}

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

		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

}