package encounter

import (
	"errors"
	authhelper "simrs-vx/internal/lib/auth"
	"strconv"
	"time"

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

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

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

	eaeh "simrs-vx/internal/domain/main-entities/adm-employee-hist"
	ea "simrs-vx/internal/domain/main-entities/ambulatory"
	ec "simrs-vx/internal/domain/main-entities/chemo"
	edc "simrs-vx/internal/domain/main-entities/death-cause"
	ed "simrs-vx/internal/domain/main-entities/doctor"
	ee "simrs-vx/internal/domain/main-entities/emergency"
	eem "simrs-vx/internal/domain/main-entities/employee"
	e "simrs-vx/internal/domain/main-entities/encounter"
	ei "simrs-vx/internal/domain/main-entities/inpatient"
	er "simrs-vx/internal/domain/main-entities/rehab"
	erdh "simrs-vx/internal/domain/main-entities/responsible-doctor-hist"
	es "simrs-vx/internal/domain/main-entities/soapi"

	uaeh "simrs-vx/internal/use-case/main-use-case/adm-employee-hist"
	ua "simrs-vx/internal/use-case/main-use-case/ambulatory"
	uc "simrs-vx/internal/use-case/main-use-case/chemo"
	udc "simrs-vx/internal/use-case/main-use-case/death-cause"
	ud "simrs-vx/internal/use-case/main-use-case/doctor"
	ue "simrs-vx/internal/use-case/main-use-case/emergency"
	uem "simrs-vx/internal/use-case/main-use-case/employee"
	ui "simrs-vx/internal/use-case/main-use-case/inpatient"
	ur "simrs-vx/internal/use-case/main-use-case/rehab"
	us "simrs-vx/internal/use-case/main-use-case/soapi"
)

const source = "encounter"

var now = time.Now()

func Create(input e.CreateDto) (*d.Data, error) {
	data := e.Encounter{}
	createSoapi := []es.CreateDto{}

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

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

	// validate SubClass
	var subCode interface{}
	subCode, err := verifyClassCode(input)
	if err != nil {
		return nil, err
	}

	// verify whether the allocated visit count has not exceeded the limit
	if input.Class_Code == ere.ECAmbulatory && subCode.(ere.AmbulatoryClassCode) == ere.ACCRehab &&
		*input.VisitMode_Code == ere.VMCSeries {

		dataEncounter, valid, err := verifyAllocatedVisitCount(input, &event)
		if err != nil {
			return nil, err
		}

		if !valid {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "visit-limit-exceeded",
				Detail: "Encounter has exceeded the allowed number of visits",
				Raw:    errors.New("visit count exceeds allowed limit"),
			}
			return nil, pl.SetLogError(&event, input)
		}

		// get data soapi
		createSoapi, err = getSoapiEncounterAdm(dataEncounter, &event)
		if err != nil {
			return nil, err
		}
	}

	// check if patient is new in the hospital
	dataPatient, err := ReadList(e.ReadListDto{
		FilterDto: e.FilterDto{Patient_Id: input.Patient_Id},
		AuthInfo:  authhelper.AuthInfo{User_Id: input.User_Id}})
	if err != nil {
		return nil, err
	}
	if list, ok := dataPatient.Data.([]e.ResponseDto); ok {
		if len(list) < 1 {
			input.NewStatus = true
		}
	}

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

		if emp, err := uem.ReadDetailData(eem.ReadDetailDto{User_Id: &input.AuthInfo.User_Id}, &event, tx); err != nil {
			return err
		} else {
			input.Adm_Employee_Id = &emp.Id
		}

		// create encounter
		if resData, err := CreateData(input, &event, tx); err != nil {
			return err
		} else {
			data = *resData
		}

		switch input.Class_Code {
		case ere.ECAmbulatory:
			subCodeAmbulatory := subCode.(ere.AmbulatoryClassCode)
			ambCreate := ea.CreateDto{
				Encounter_Id:   &data.Id,
				Class_Code:     subCodeAmbulatory,
				VisitMode_Code: *input.VisitMode_Code,
			}
			_, err = ua.CreateData(ambCreate, &event, tx)
			if err != nil {
				return err
			}

			if subCodeAmbulatory == ere.ACCChemo {
				chemoCreate := ec.CreateDto{
					Encounter_Id: &data.Id,
					Status_Code:  erc.DVCNew,
					SrcUnit_Id:   input.Unit_Id,
				}
				_, err = uc.CreateData(chemoCreate, &event, tx)
				if err != nil {
					return err
				}
			}

			if subCodeAmbulatory == ere.ACCRehab && *input.VisitMode_Code == ere.VMCAdm {
				// create data rehab
				if _, err = ur.CreateData(er.CreateDto{
					Encounter_Id:        &data.Id,
					Doctor_Id:           input.Appointment_Doctor_Id,
					AllocatedVisitCount: input.AllocatedVisitCount}, &event, tx); err != nil {
					return err
				}
			} else if subCodeAmbulatory == ere.ACCRehab && *input.VisitMode_Code == ere.VMCSeries {
				// Insert Soapi
				if err = us.CreateBulkData(createSoapi, data.Id, &event, tx); err != nil {
					return err
				}
			}

		case ere.ECEmergency:
			emerCreate := ee.CreateDto{
				Encounter_Id: &data.Id,
				Class_Code:   subCode.(ere.EmergencyClassCode),
			}
			_, err = ue.CreateData(emerCreate, &event, tx)
			if err != nil {
				return err
			}
		case ere.ECInpatient:
			inpCreate := ei.CreateDto{
				Encounter_Id: &data.Id,
				Class_Code:   subCode.(ere.InpatientClassCode),
				Infra_Id:     input.Infra_Id,
			}
			_, err = ui.CreateData(inpCreate, &event, tx)
			if err != nil {
				return err
			}
		default:
			return errors.New("invalid encounter class code")
		}

		// insert adm_employee_hist
		if _, err := uaeh.CreateData(eaeh.CreateDto{
			Encounter_Id: &data.Main.Id,
			Employee_Id:  data.Adm_Employee_Id,
			StartedAt:    &now}, &event, tx); err != nil {
			return err
		}

		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: data.ToResponse(),
	}, nil
}

func ReadList(input e.ReadListDto) (*d.Data, error) {
	var data *e.Encounter
	var dataList []e.Encounter
	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 {
		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.Encounter
	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: uint16(input.Id)}
	var data *e.Encounter
	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
		}

		if data.IsDone() {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-state-mismatch",
				Detail: "encounter is done",
				Raw:    errors.New("encounter is done"),
			}
			return pl.SetLogError(&event, input)
		}

		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: uint16(input.Id)}
	var data *e.Encounter
	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 CheckOut(input e.DischargeDto) (*d.Data, error) {
	rdDto := e.ReadDetailDto{Id: uint16(input.Id), Includes: "Ambulatory"}
	var data *e.Encounter
	var err error

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

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

	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.IsDone() {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-state-mismatch",
				Detail: "encounter is done",
				Raw:    errors.New("encounter is done"),
			}
			return pl.SetLogError(&event, input)
		}

		if data.Ambulatory != nil && (data.Ambulatory.Class_Code == ere.ACCReg || data.Ambulatory.Class_Code == ere.ACCRehab) {
			// validate if soapi exist
			err = getSoapiByTypeCode(input.Id, *data.Ambulatory, &event, "check-out")
			if err != nil {
				return err
			}
		} else {
			// chemo TBC
			if err := checkSoapiByDocExists(data.Id, &event, tx); err != nil {
				return err
			}
		}

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

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

		if err := createMedication(data.Id, &event, tx); err != nil {
			if !pu.IsDataNotFoundError(err) {
				return err
			}
		}

		// update finishedAt in latest responsible_doctor_hist
		if err = updateLatestResponsibleDoctorHist(e.CheckinDto{Id: input.Id, StartedAt: &now}, &event, tx); err != nil {
			return err
		}

		// update finishedAt in latest adm_employee_hist
		if err = updateLatestAdmEmployeeHist(e.CheckinDto{Id: input.Id, StartedAt: &now}, &event, tx); err != nil {
			return err
		}

		switch *input.Discharge_Method_Code {
		case ere.DMCDeath:
			// insert data death-cause
			if _, err = udc.CreateData(edc.CreateDto{Encounter_Id: &input.Id, Value: input.DeathCause}, &event, tx); err != nil {
				return err
			}
		case ere.DMCConsulPoly, ere.DMCConsulExecutive:
			// bulk insert internal-references
			if err = createInternalReferences(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.IS{
			"source":    source,
			"structure": "single-data",
			"status":    "checkOut",
		},
		Data: data.ToResponse(),
	}, nil
}

func UpdateStatusCode(input e.UpdateStatusDto) (*d.Data, error) {
	rdDto := e.ReadDetailDto{Id: input.Id}
	var data *e.Encounter
	var err error

	event := pl.Event{
		Feature: "Update Status Code",
		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
		}

		if data.IsDone() {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-state-mismatch",
				Detail: "encounter is done",
				Raw:    errors.New("encounter is done"),
			}
			return pl.SetLogError(&event, input)
		}

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

		if err := UpdateStatusData(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 CheckIn(input e.CheckinDto) (*d.Data, error) {
	rdDto := e.ReadDetailDto{Id: uint16(input.Id), Includes: "Rehab,Ambulatory"}
	var data *e.Encounter
	var err error

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

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

	// validate foreign key
	if err := validateForeignKey(input); err != nil {
		return nil, err
	}

	// set startedAt
	if input.StartedAt == nil {
		input.StartedAt = &now
	}

	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.IsDone() {
			event.Status = "failed"
			event.ErrInfo = pl.ErrorInfo{
				Code:   "data-state-mismatch",
				Detail: "encounter is done",
				Raw:    errors.New("encounter is done"),
			}
			return pl.SetLogError(&event, input)
		}

		// validate if soapi exist
		if data.Ambulatory != nil && (data.Ambulatory.Class_Code == ere.ACCReg || data.Ambulatory.Class_Code == ere.ACCRehab) {
			err = getSoapiByTypeCode(input.Id, *data.Ambulatory, &event, "check-in")
			if err != nil {
				return err
			}
		}

		// Insert responsible_doctor_hist if responsible_doctor_id has changed && update latest history
		if data.Responsible_Doctor_Id == nil || *input.Responsible_Doctor_Id != *data.Responsible_Doctor_Id {
			// upsert responsibleDoctorHist
			if err = upsertResponsibleDoctorHist(erdh.CreateDto{
				Encounter_Id: &data.Id,
				Doctor_Id:    input.Responsible_Doctor_Id,
				StartedAt:    input.StartedAt,
			}, &event, tx); err != nil {
				return err
			}
		}

		// Insert adm_employee_hist if adm_employee_id has changed && update latest history
		if input.Adm_Employee_Id != nil && *input.Adm_Employee_Id != *data.Adm_Employee_Id {
			// upsert admEmployeeHist
			if err = upsertAdmEmployeeHist(eaeh.CreateDto{
				Encounter_Id: &data.Id,
				Employee_Id:  input.Adm_Employee_Id,
				StartedAt:    input.StartedAt,
			}, &event, tx); err != nil {
				return err
			}
		}

		// update encounter data
		if err := updateCheckInData(input, data, &event, tx); err != nil {
			return err
		}

		if data.Ambulatory.Class_Code == ere.ACCRehab {
			if err := updateRehabDoctor(er.UpdateDto{CreateDto: er.CreateDto{
				Encounter_Id: &data.Id,
				Doctor_Id:    input.Responsible_Doctor_Id,
			}}, &event, tx); err != nil {
				return err
			}
		}

		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":    "checkIn",
		},
		Data: data.ToResponse(),
	}, nil
}

func validateForeignKey(input e.CheckinDto) error {
	// validate employee_Id
	if input.Adm_Employee_Id != nil {
		if _, err := uem.ReadDetail(eem.ReadDetailDto{Id: uint16(*input.Adm_Employee_Id)}); err != nil {
			return err
		}
	}

	// validate doctor_id
	if input.Responsible_Doctor_Id != nil {
		if _, err := ud.ReadDetail(ed.ReadDetailDto{Id: uint16(*input.Responsible_Doctor_Id)}); err != nil {
			return err
		}
	}

	return nil
}

func verifyClassCode(input e.CreateDto) (subCode interface{}, err error) {
	switch input.Class_Code {
	case ere.ECAmbulatory:
		subCode, err = ua.CheckClassCode(input.SubClass_Code)
		if err != nil {
			return nil, err
		}
	case ere.ECEmergency:
		subCode, err = ue.CheckClassCode(input.SubClass_Code)
		if err != nil {
			return nil, err
		}
	case ere.ECInpatient:
		subCode, err = ui.CheckClassCode(input.SubClass_Code)
		if err != nil {
			return nil, err
		}
	default:
		return nil, errors.New("invalid encounter class code")
	}
	return
}