package sql

import (
	"database/sql"
	"errors"
	"github.com/google/uuid"
	"github.com/lib/pq"
	"mangezmieux-backend/internal/acl/model"
	model2 "mangezmieux-backend/internal/model"
	"mangezmieux-backend/internal/postgres"
)

func (sqlDAO dao) GetRole(id uuid.UUID) (*model.Role, error) {
	q := `
		SELECT id, name, creation_date, last_update_date
		FROM mangezmieux.role r
		WHERE r.id = $1
	`
	row := sqlDAO.client.QueryRow(q, id.String())

	role := &model.Role{}
	err := row.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
	var errPq *pq.Error
	if errors.As(err, &errPq) {
		return nil, postgres.HandlePgError(errPq)
	}
	if errors.Is(err, sql.ErrNoRows) {
		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
	}
	return role, nil
}

func (sqlDAO dao) GetRoleByName(name string) (*model.Role, error) {
	q := `
		SELECT id, name, creation_date, last_update_date
		FROM mangezmieux.role r
		WHERE r.name = $1
	`
	row := sqlDAO.client.QueryRow(q, name)

	role := &model.Role{}
	err := row.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
	var errPq *pq.Error
	if errors.As(err, &errPq) {
		return nil, postgres.HandlePgError(errPq)
	}
	if errors.Is(err, sql.ErrNoRows) {
		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
	}
	return role, nil
}

func (sqlDAO dao) AddRole(roleName string, metadata model2.Metadata) (*model.Role, error) {
	var id uuid.UUID
	q := `
			INSERT INTO mangezmieux.role
				(name, creation_date, creation_user)
			VALUES
				($1,$2,$3)
			RETURNING
				id`

	err := sqlDAO.client.QueryRow(q, roleName, metadata.CreationDate, metadata.CreationUser).Scan(&id)

	var errPq *pq.Error
	if errors.As(err, &errPq) {
		return nil, postgres.HandlePgError(errPq)
	}

	role, err := sqlDAO.GetRole(id)
	if errors.As(err, &errPq) {
		return nil, postgres.HandlePgError(errPq)
	}

	return role, nil
}

func (sqlDAO dao) DeleteRole(id uuid.UUID) error {
	q := `
		DELETE FROM mangezmieux.role
		WHERE id = $1 
	`

	_, err := sqlDAO.client.Exec(q, id.String())
	var errPq *pq.Error
	if errors.As(err, &errPq) {
		return postgres.HandlePgError(errPq)
	}
	return err
}

func (sqlDAO dao) GetAllRole() ([]*model.Role, error) {
	q := `
		SELECT id, name, creation_date, last_update_date
		FROM mangezmieux.role r
	`
	rows, err := sqlDAO.client.Query(q)
	if err != nil {
		return nil, err
	}

	if rows.Err() != nil {
		return nil, rows.Err()
	}

	defer rows.Close()
	roles := make([]*model.Role, 0)
	for rows.Next() {
		role := &model.Role{}
		err := rows.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
		var errPq *pq.Error
		if errors.As(err, &errPq) {
			return nil, postgres.HandlePgError(errPq)
		}
		if errors.Is(err, sql.ErrNoRows) {
			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
		}
		roles = append(roles, role)
	}
	return roles, nil
}