package sql

import (
	"database/sql"
	"errors"
	"mangezmieux-backend/internal/acl/model"
	model2 "mangezmieux-backend/internal/model"
	"mangezmieux-backend/internal/postgres"

	"github.com/google/uuid"
	"github.com/lib/pq"
)

func (sqlDAO dao) GetRoleVerbResource(id uuid.UUID) (*model.RoleVerbResource, error) {
	q := `
		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
		FROM mangezmieux.role_verb_resource r
		WHERE r.id = $1
	`
	row := sqlDAO.client.QueryRow(q, id.String())

	roleVerbResource := &model.RoleVerbResource{}
	err := row.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.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 roleVerbResource, nil
}

func (sqlDAO dao) GetRoleVerbResourceByRoleResourceAndVerb(roleId, resourceId uuid.UUID, verb string) (*model.RoleVerbResource, error) {
	q := `
		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
		FROM mangezmieux.role_verb_resource r
		WHERE r.role_id = $1 
		AND r.resource_id = $2
		AND r.verb = $3
	`
	row := sqlDAO.client.QueryRow(q, roleId.String(), resourceId.String(), verb)

	roleVerbResource := &model.RoleVerbResource{}
	err := row.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.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 roleVerbResource, nil
}

func (sqlDAO dao) GetRoleVerbResourceByResourceAndVerb(resourceId uuid.UUID, verb string) ([]*model.RoleVerbResource, error) {
	q := `
		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
		FROM mangezmieux.role_verb_resource r
		WHERE r.resource_id = $1
		AND r.verb = $2
	`
	rows, err := sqlDAO.client.Query(q, resourceId.String(), verb)
	if err != nil {
		return nil, err
	}

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

	defer rows.Close()
	roleVerResources := make([]*model.RoleVerbResource, 0)
	for rows.Next() {
		roleVerbResource := &model.RoleVerbResource{}
		err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.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)
		}
		roleVerResources = append(roleVerResources, roleVerbResource)
	}
	return roleVerResources, nil
}

func (sqlDAO dao) GetRoleVerbResourceByRoleResource(roleId, resourceId uuid.UUID) ([]*model.RoleVerbResource, error) {
	q := `
		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
		FROM mangezmieux.role_verb_resource r
		WHERE r.role_id = $1 
		AND r.resource_id = $2
	`
	rows, err := sqlDAO.client.Query(q, roleId.String(), resourceId.String())
	if err != nil {
		return nil, err
	}

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

	defer rows.Close()
	roleVerResources := make([]*model.RoleVerbResource, 0)
	for rows.Next() {
		roleVerbResource := &model.RoleVerbResource{}
		err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.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)
		}
		roleVerResources = append(roleVerResources, roleVerbResource)
	}
	return roleVerResources, nil
}

func (sqlDAO dao) GetRoleVerbResourceByRole(roleId uuid.UUID) ([]*model.RoleVerbResource, error) {
	q := `
		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
		FROM mangezmieux.role_verb_resource r
		WHERE r.role_id = $1 
	`
	rows, err := sqlDAO.client.Query(q, roleId.String())
	if err != nil {
		return nil, err
	}

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

	defer rows.Close()
	roleVerResources := make([]*model.RoleVerbResource, 0)
	for rows.Next() {
		roleVerbResource := &model.RoleVerbResource{}
		err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.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)
		}
		roleVerResources = append(roleVerResources, roleVerbResource)
	}
	return roleVerResources, nil
}

func (sqlDAO dao) AddRoleVerbResource(roleId, resourceId uuid.UUID, verb string, metadata model2.Metadata) (*model.RoleVerbResource, error) {
	var Id uuid.UUID
	q := `
			INSERT INTO mangezmieux.role_verb_resource
				(role_id, verb, resource_id, creation_date, creation_user)
			VALUES
				($1,$2,$3,$4,$5)
			RETURNING
				Id`

	err := sqlDAO.client.QueryRow(q, roleId.String(), verb, resourceId.String(), metadata.CreationDate, metadata.CreationUser).Scan(&Id)

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

	roleVerbResource, err := sqlDAO.GetRoleVerbResource(Id)
	if errors.As(err, &errPq) {
		return nil, postgres.HandlePgError(errPq)
	}

	return roleVerbResource, nil
}

func (sqlDAO dao) DeleteRoleVerbResource(id uuid.UUID) error {
	q := `
		DELETE FROM mangezmieux.role_verb_resource
		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
}