package dashboard

import (
	"antrian-operasi/internal/database"

	queryUtils "antrian-operasi/internal/utils/query"

	"context"
)

const DB_NAME = "db_antrian"
const TBL_NAME = "data_pasien_operasi"
const TBL_SUBSPESIALIS = "daftar_subspesialis"

type IDashboardRepository interface {
	GetAntrianPerKategori(c context.Context) ([]AntrianPerKategori, error)
	GetAntrianPerSpesialis(c context.Context) (ListModelAntrianPerSpesialis, error)
	GetPerbandinganStatusAntrean(c context.Context, req PeriodeDashboardRequest) (ListPerbandinganStatusAntrean, error)
	GetPerbandinganKategoriAntrean(c context.Context, req PeriodeDashboardRequest) ([]PerbandinganKategoriAntrean, error)
	GetAntrianPerHari(c context.Context, req PeriodeDashboardRequest) ([]AntrianPerHari, error)
	GetTableAntrianPerSpesialis(c context.Context, req PeriodeDashboardRequest) ([]TableAntreanPerSpesialis, error)
	GetTableAntrianPerSubSpesialis(c context.Context, req PeriodeDashboardRequest) ([]TableAntreanPerSubSpesialis, error)
}

type dashboardRepo struct {
	queryBuilder *queryUtils.QueryBuilder
	db           database.Service
}

func NewRepository(dbService database.Service) IDashboardRepository {
	queryBuilder := queryUtils.NewQueryBuilder(queryUtils.DBTypePostgreSQL).
		SetAllowedColumns([]string{
			"Kategori_operasi",
			"Kategori",
			"jumlah_antrean",
		})
	queryBuilder.SetSecurityOptions(false, 100)

	return dashboardRepo{
		queryBuilder: queryBuilder,
		db:           dbService,
	}
}

func (r dashboardRepo) GetAntrianPerKategori(c context.Context) ([]AntrianPerKategori, error) {
	var result []AntrianPerKategori

	query := queryUtils.DynamicQuery{
		From:    TBL_NAME,
		Aliases: "dpo",
		Fields: []queryUtils.SelectField{
			{Expression: "dpo.Kategori_operasi", Alias: "Kategori_operasi"},
			{Expression: "dko.Kategori", Alias: "Kategori"},
			{Expression: "COUNT(dpo.id)", Alias: "jumlah_antrean"},
		},
		GroupBy: []string{"dpo.Kategori_operasi", "dko.Kategori"},
		Sort: []queryUtils.SortField{
			{Column: "dko.Kategori", Order: "ASC"},
		},
	}

	query.Joins = []queryUtils.Join{
		{
			Type:  "LEFT",
			Table: "daftar_kategori_operasi",
			Alias: "dko",
			OnConditions: queryUtils.FilterGroup{
				Filters: []queryUtils.DynamicFilter{
					{
						Column: "dpo.Kategori_operasi", Operator: queryUtils.OpEqual, Value: "dko.id",
					},
				},
			},
		},
	}

	// filter status = 1 (belum)
	var filter []queryUtils.DynamicFilter
	filter = append(filter, queryUtils.DynamicFilter{Column: "dpo.Status_operasi", Operator: queryUtils.OpEqual, Value: "1"})
	query.Filters = append(query.Filters, queryUtils.FilterGroup{Filters: filter, LogicOp: "AND"})

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		return result, err
	}

	return result, nil
}

func (r dashboardRepo) GetAntrianPerSpesialis(c context.Context) (ListModelAntrianPerSpesialis, error) {
	var result ListModelAntrianPerSpesialis

	query := queryUtils.DynamicQuery{
		From:    TBL_SUBSPESIALIS,
		Aliases: "dss",
		Fields: []queryUtils.SelectField{
			{Expression: "ds.id", Alias: "id_spesialis"},
			{Expression: "dss.id", Alias: "id_subspesialis"},
			{Expression: "ds.Spesialis"},
			{Expression: "dss.Subspesialis"},
			{Expression: "COUNT(dpo.id)", Alias: "jml_antrian"},
		},
		Joins: []queryUtils.Join{
			{
				Type:  "LEFT",
				Table: "daftar_spesialis",
				Alias: "ds",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{
							Column: "dss.FK_daftar_spesialis_ID", Operator: queryUtils.OpEqual, Value: "ds.id",
						},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "data_pasien_operasi",
				Alias: "dpo",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{
							Column: "dpo.Sub_spesialis", Operator: queryUtils.OpEqual, Value: "dss.id",
						},
						{
							Column: "dpo.Status_operasi", Operator: queryUtils.OpEqual, Value: "1",
						},
					}, LogicOp: "AND",
				},
			},
		},
		GroupBy: []string{"dss.id", "dss.Subspesialis", "ds.id", "ds.Spesialis"},
		Sort: []queryUtils.SortField{
			{Column: "ds.id"},
		},
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		return result, err
	}

	return result, nil
}

func (r dashboardRepo) GetPerbandinganStatusAntrean(c context.Context, req PeriodeDashboardRequest) (ListPerbandinganStatusAntrean, error) {
	var result ListPerbandinganStatusAntrean
	startDate, endDate := GenerateStartEndDate(req)

	query := queryUtils.DynamicQuery{
		From:    TBL_NAME,
		Aliases: "dpo",
		Fields: []queryUtils.SelectField{
			{Expression: "dpo.Status_operasi", Alias: "status_operasi"},
			{Expression: "COUNT(dpo.id)", Alias: "jumlah"},
		},
		Filters: []queryUtils.FilterGroup{
			{
				Filters: []queryUtils.DynamicFilter{
					{Column: "dpo.Tanggal_daftar", Operator: queryUtils.OpBetween, Value: []string{startDate, endDate}},
				},
			},
		},
		GroupBy: []string{"dpo.Status_operasi"},
		Sort: []queryUtils.SortField{
			{Column: "dpo.Status_operasi", Order: "ASC"},
		},
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		return result, err
	}

	return result, nil
}

func (r dashboardRepo) GetPerbandinganKategoriAntrean(c context.Context, req PeriodeDashboardRequest) ([]PerbandinganKategoriAntrean, error) {
	var result []PerbandinganKategoriAntrean

	startDate, endDate := GenerateStartEndDate(req)

	query := queryUtils.DynamicQuery{
		From:    "daftar_kategori_operasi",
		Aliases: "dko",
		Fields: []queryUtils.SelectField{
			{Expression: "dko.id", Alias: "id_kategori"},
			{Expression: "dko.Kategori", Alias: "kategori"},
			{Expression: "COUNT(dpo.id)", Alias: "jumlah"},
		},
		Joins: []queryUtils.Join{
			{
				Type:  "LEFT",
				Table: TBL_NAME,
				Alias: "dpo",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "dpo.Kategori_operasi", Operator: queryUtils.OpEqual, Value: "dko.id"},
						{Column: "dpo.Tanggal_daftar", Operator: queryUtils.OpBetween, Value: []string{startDate, endDate}},
					}, LogicOp: "AND",
				},
			},
		},
		GroupBy: []string{"dko.id", "dko.Kategori"},
		Sort: []queryUtils.SortField{
			{Column: "dko.id", Order: "ASC"},
		},
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		return result, err
	}

	return result, nil
}

func (r dashboardRepo) GetAntrianPerHari(c context.Context, req PeriodeDashboardRequest) ([]AntrianPerHari, error) {
	var result []AntrianPerHari

	startDate, endDate := GenerateStartEndDate(req)

	query := queryUtils.DynamicQuery{
		From:    TBL_NAME,
		Aliases: "dpo",
		Fields: []queryUtils.SelectField{
			{Expression: "DATE(dpo.\"Tanggal_daftar\")", Alias: "tanggal_daftar"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('1')) as belum"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('2')) as selesai"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('3')) as tunda"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('4')) as batal"},
		},
		Filters: []queryUtils.FilterGroup{
			{
				Filters: []queryUtils.DynamicFilter{
					{Column: "dpo.Tanggal_daftar", Operator: queryUtils.OpBetween, Value: []string{startDate, endDate}},
				},
			},
		},
		GroupBy: []string{"DATE(dpo.\"Tanggal_daftar\")"},
		Sort: []queryUtils.SortField{
			{Column: "DATE(dpo.\"Tanggal_daftar\")", Order: "ASC"},
		},
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		return result, err
	}

	return result, nil
}

func (r dashboardRepo) GetTableAntrianPerSpesialis(c context.Context, req PeriodeDashboardRequest) ([]TableAntreanPerSpesialis, error) {
	var result []TableAntreanPerSpesialis

	startDate, endDate := GenerateStartEndDate(req)

	query := queryUtils.DynamicQuery{
		From:    TBL_NAME,
		Aliases: "dpo",
		Fields: []queryUtils.SelectField{
			{Expression: "ds.Spesialis", Alias: "spesialis"},
			{Expression: "count(dpo.id) as total"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('1')) as belum"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('2')) as selesai"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('3')) as tunda"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('4')) as batal"},
		},
		Filters: []queryUtils.FilterGroup{
			{
				Filters: []queryUtils.DynamicFilter{
					{Column: "dpo.Tanggal_daftar", Operator: queryUtils.OpBetween, Value: []string{startDate, endDate}},
				},
			},
		},
		Joins: []queryUtils.Join{
			{
				Type:  "LEFT",
				Table: "daftar_spesialis",
				Alias: "ds",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "dpo.Spesialis", Operator: queryUtils.OpEqual, Value: "ds.id"},
					},
				},
			},
		},
		GroupBy: []string{"ds.Spesialis"},
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		return result, err
	}

	return result, nil
}

func (r dashboardRepo) GetTableAntrianPerSubSpesialis(c context.Context, req PeriodeDashboardRequest) ([]TableAntreanPerSubSpesialis, error) {
	var result []TableAntreanPerSubSpesialis

	startDate, endDate := GenerateStartEndDate(req)

	query := queryUtils.DynamicQuery{
		From:    TBL_NAME,
		Aliases: "dpo",
		Fields: []queryUtils.SelectField{
			{Expression: "ds.Spesialis", Alias: "spesialis"},
			{Expression: "dss.Subspesialis", Alias: "sub_spesialis"},
			{Expression: "count(dpo.id) as total"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('1')) as belum"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('2')) as selesai"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('3')) as tunda"},
			{Expression: "count(dpo.id) filter (where dpo.\"Status_operasi\" = ('4')) as batal"},
		},
		Filters: []queryUtils.FilterGroup{
			{
				Filters: []queryUtils.DynamicFilter{
					{Column: "dpo.Tanggal_daftar", Operator: queryUtils.OpBetween, Value: []string{startDate, endDate}},
				},
			},
		},
		Joins: []queryUtils.Join{
			{
				Type:  "LEFT",
				Table: "daftar_spesialis",
				Alias: "ds",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "dpo.Spesialis", Operator: queryUtils.OpEqual, Value: "ds.id"},
					},
				},
			},
			{
				Type:  "LEFT",
				Table: "daftar_subspesialis",
				Alias: "dss",
				OnConditions: queryUtils.FilterGroup{
					Filters: []queryUtils.DynamicFilter{
						{Column: "dpo.Sub_spesialis", Operator: queryUtils.OpEqual, Value: "dss.id"},
					},
				},
			},
		},
		GroupBy: []string{"ds.Spesialis", "dss.Subspesialis"},
		Sort: []queryUtils.SortField{
			{Column: "ds.Spesialis", Order: "ASC"},
		},
	}

	dbconn, err := r.db.GetSQLXDB(DB_NAME)
	if err != nil {
		return result, err
	}

	err = r.queryBuilder.ExecuteQuery(
		c, dbconn, query, &result)
	if err != nil {
		return result, err
	}

	return result, nil
}