package database

import (
	"netidhub-saas-be/app/database/entity"
	"netidhub-saas-be/app/database/entity/article_category_details"
	"netidhub-saas-be/config/config"

	"github.com/rs/zerolog"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

// Database setup database with gorm
type Database struct {
	DB  *gorm.DB
	Log zerolog.Logger
	Cfg *config.Config
}

type Seeder interface {
	Seed(*gorm.DB) error
	Count(*gorm.DB) (int, error)
}

func NewDatabase(cfg *config.Config, log zerolog.Logger) *Database {
	db := &Database{
		Cfg: cfg,
		Log: log,
	}

	return db
}

// ConnectDatabase connect database
func (_db *Database) ConnectDatabase() {
	logMode := _db.Cfg.DB.Postgres.LogMode
	var logLevel logger.LogLevel

	switch logMode {
	case "INFO":
		logLevel = logger.Info
	case "WARN":
		logLevel = logger.Warn
	case "ERROR":
		logLevel = logger.Error
	case "NONE":
		logLevel = logger.Silent
	default:
		logLevel = logger.Silent
	}

	// var logLevel logger.LogLevel
	// if logMode == "INFO" {
	// 	logLevel = logger.Info
	// } else if logMode == "WARN" {
	// 	logLevel = logger.Warn
	// } else if logMode == "ERROR" {
	// 	logLevel = logger.Error
	// } else if logMode == "NONE" {
	// 	logLevel = logger.Silent
	// }

	conn, err := gorm.Open(postgres.Open(_db.Cfg.DB.Postgres.DSN), &gorm.Config{
		Logger: logger.Default.LogMode(logLevel),
	})
	if err != nil {
		_db.Log.Error().Err(err).Msg("An unknown error occurred when to connect the database!")
	} else {
		_db.Log.Info().Msg("Connected the database succesfully!")
	}

	_db.DB = conn
}

// ShutdownDatabase shutdown database
func (_db *Database) ShutdownDatabase() {
	sqlDB, err := _db.DB.DB()
	if err != nil {
		_db.Log.Error().Err(err).Msg("An unknown error occurred when to shutdown the database!")
	} else {
		_db.Log.Info().Msg("Shutdown the database succesfully!")
	}
	sqlDB.Close()
}

// MigrateModels migrate models
func (_db *Database) MigrateModels() {
	err := _db.DB.AutoMigrate(
		Models()...,
	)
	if err != nil {
		_db.Log.Error().Err(err).Msg("An unknown error occurred when to migrate the database!")
	} else {
		_db.Log.Info().Msg("Migrate the database entity succesfully!")
	}
}

// Models list of models for migration
func Models() []interface{} {
	return []interface{}{
		entity.ActivityLogs{},
		entity.ActivityLogTypes{},
		entity.Advertisement{},
		entity.ApprovalWorkflows{},
		entity.ApprovalWorkflowSteps{},
		entity.Articles{},
		entity.ArticleApprovalFlows{},
		entity.ArticleApprovalStepLogs{},
		entity.ArticleCategories{},
		entity.ArticleApprovals{},
		article_category_details.ArticleCategoryDetails{},
		entity.ArticleFiles{},
		entity.ArticleComments{},
		entity.ArticleNulisAI{},
		entity.AuditTrails{},
		entity.Bookmarks{},
		entity.Cities{},
		entity.Clients{},
		entity.ClientApprovalSettings{},
		entity.CsrfTokenRecords{},
		entity.CustomStaticPages{},
		entity.Districts{},
		entity.Feedbacks{},
		entity.ForgotPasswords{},
		entity.Magazines{},
		entity.MagazineFiles{},
		entity.MasterMenus{},
		entity.MasterModules{},
		entity.MasterStatuses{},
		entity.MasterApprovalStatuses{},
		entity.Provinces{},
		entity.OneTimePasswords{},
		entity.Subscription{},
		entity.Schedules{},
		entity.UserLevels{},
		entity.UserRoles{},
		entity.UserRoleAccesses{},
		entity.Users{},
		entity.UserRoleLevelDetails{},
		entity.UserClientAccess{}, // New: Multi-client access for users
	}
}

// SeedModels seed data
func (_db *Database) SeedModels(seeder []Seeder) {
	for _, seed := range seeder {
		count, err := seed.Count(_db.DB)
		if err != nil {
			_db.Log.Error().Err(err).Msg("An unknown error occurred when to seed the database!")
		}

		if count == 0 {
			if err := seed.Seed(_db.DB); err != nil {
				_db.Log.Error().Err(err).Msg("An unknown error occurred when to seed the database!")
			}

			_db.Log.Info().Msg("Seeded the database successfully!")
		} else {
			_db.Log.Info().Msg("Database is already seeded!")
		}
	}

	_db.Log.Info().Msg("Seeded the database succesfully!")
}