package AccessHandler

import (
	"gitea.tecamino.com/paadi/dbHandler"
	"gitea.tecamino.com/paadi/tecamino-logger/logging"
)

// AccessHandler
//
// Description:
//
//	AccessHandler manages access-related functionality, including
//	database operations for users and roles, as well as logging.
//	It encapsulates a database handler and a logger so that
//	authentication and authorization operations can be performed
//	consistently across the application.
type AccessHandler struct {
	dbHandler *dbHandler.DBHandler // Database handler used for managing users and roles
	logger    *logging.Logger      // Centralized application logger
}

// NewAccessHandler
//
// Description:
//
//	Creates and initializes a new AccessHandler instance.
//
// Behavior:
//  1. If a logger is not provided (nil), it creates a new logger instance
//     that writes to "accessHandler.log".
//  2. Initializes the AccessHandler struct.
//  3. Sets up the internal DBAHandler with the same logger.
//  4. Automatically creates required database tables and default data:
//     - User table
//     - Default user(s)
//     - Role table
//     - Default role(s)
//
// Parameters:
//   - dbPath: The file path to the database.
//   - logger: Optional pointer to a logging.Logger instance. If nil, a new one is created.
//
// Returns:
//   - aH:  A pointer to the fully initialized AccessHandler.
//   - err: Any error that occurs during initialization.
//
// Example:
//
//	handler, err := NewAccessHandler("data/app.db", appLogger)
//	if err != nil {
//	    log.Fatal(err)
//	}
func NewAccessHandler(path string, logger *logging.Logger) (aH *AccessHandler, err error) {
	if logger == nil {
		logger, err = logging.NewLogger("accessHandler.log", nil)
		if err != nil {
			return
		}
	}

	logger.Debug("NewAccessHandler", "initialize new access handler")

	// Initialize AccessHandler with logger
	aH = &AccessHandler{
		logger: logger,
	}

	logger.Debug("NewAccessHandler", "initialize db handler")
	// Create a new DB handler instance
	aH.dbHandler, err = dbHandler.NewDBHandler(path, "user", logger)
	if err != nil {
		aH.logger.Error("NewAccessHandler", err)
		return
	}

	logger.Debug("NewAccessHandler", "add user table")
	// Add the user table to the database
	err = aH.AddUserTable()
	if err != nil {
		aH.logger.Error("NewAccessHandler", err)
		return
	}

	logger.Debug("NewAccessHandler", "add default user")
	// Add default users to the system
	err = aH.AddDefaultUser()
	if err != nil {
		aH.logger.Error("NewAccessHandler", err)
		return
	}

	logger.Debug("NewAccessHandler", "add role table")
	// Add the role table to the database
	err = aH.AddRoleTable()
	if err != nil {
		aH.logger.Error("NewAccessHandler", err)
		return
	}

	logger.Debug("NewAccessHandler", "add default role")
	// Add default roles to the system
	err = aH.AddDefaultRole()
	if err != nil {
		aH.logger.Error("NewAccessHandler", err)
	}

	return
}

// GetLogger
//
// Description:
//
//	Returns the logger associated with this AccessHandler instance.
//	Useful when another component or handler needs to reuse the
//	same logging instance for consistent log output.
//
// Returns:
//   - *logging.Logger: The logger assigned to this AccessHandler.
//
// Example:
//
//	log := accessHandler.GetLogger()
//	log.Info("Some event")
func (aH *AccessHandler) GetLogger() *logging.Logger {
	return aH.logger
}