package repository

import (
	"fmt"

	"github.com/go-pg/pg/v10"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"github.com/tiptok/godevp/pkg/domain"
	"github.com/tiptok/godevp/pkg/infrastructure/pg/models"
)

type AccessRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

func (repository *AccessRepository) nextIdentify() (int64, error) {
	return 0, nil
}
func (repository *AccessRepository) Save(access *domain.Access) (*domain.Access, error) {
	tx := repository.transactionContext.PgTx
	if access.Identify() == nil {
		_, err := repository.nextIdentify()
		if err != nil {
			return access, err
		}
		if _, err := tx.QueryOne(
			pg.Scan(&access.Id, &access.ParentId, &access.AccessName, &access.AccessCode, &access.AccessType, &access.Sort, &access.Object, &access.Action, &access.Module, &access.Icon, &access.Status),
			"INSERT INTO access (id, parent_id, access_name, access_code, access_type, sort, object, action, module, icon, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id, parent_id, access_name, access_code, access_type, sort, object, action, module, icon, status",
			access.Id, access.ParentId, access.AccessName, access.AccessCode, access.AccessType, access.Sort, access.Object, access.Action, access.Module, access.Icon, access.Status); err != nil {
			return access, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&access.Id, &access.ParentId, &access.AccessName, &access.AccessCode, &access.AccessType, &access.Sort, &access.Object, &access.Action, &access.Module, &access.Icon, &access.Status),
			"UPDATE access SET id=?, parent_id=?, access_name=?, access_code=?, access_type=?, sort=?, object=?, action=?, module=?, icon=?, status=? WHERE id=? RETURNING id, parent_id, access_name, access_code, access_type, sort, object, action, module, icon, status",
			access.Id, access.ParentId, access.AccessName, access.AccessCode, access.AccessType, access.Sort, access.Object, access.Action, access.Module, access.Icon, access.Status, access.Identify()); err != nil {
			return access, err
		}
	}
	return access, nil
}
func (repository *AccessRepository) Remove(access *domain.Access) (*domain.Access, error) {
	tx := repository.transactionContext.PgTx
	accessModel := new(models.Access)
	accessModel.Id = access.Identify().(int64)
	if _, err := tx.Model(accessModel).WherePK().Delete(); err != nil {
		return access, err
	}
	return access, nil
}
func (repository *AccessRepository) FindOne(queryOptions map[string]interface{}) (*domain.Access, error) {
	tx := repository.transactionContext.PgDd
	accessModel := new(models.Access)
	query := tx.Model(accessModel)
	if accessId, ok := queryOptions["id"]; ok {
		query = query.Where("access.id = ?", accessId)
	}
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if accessModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(accessModel)
	}
}
func (repository *AccessRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.Access, error) {
	tx := repository.transactionContext.PgDd
	var accessModels []*models.Access
	accesss := make([]*domain.Access, 0)
	query := tx.Model(&accessModels)
	if offset, ok := queryOptions["offset"]; ok {
		offset := offset.(int)
		if offset > -1 {
			query = query.Offset(offset)
		}
	} else {
		query = query.Offset(0)
	}
	if limit, ok := queryOptions["limit"]; ok {
		limit := limit.(int)
		if limit > -1 {
			query = query.Limit(limit)
		}
	} else {
		query = query.Limit(20)
	}
	if inAccessIds, ok := queryOptions["inAccessIds"]; ok {
		query.Where("id in (?)", pg.In(inAccessIds))
	}

	if sortByParentId, ok := queryOptions["sortByParentId"]; ok {
		query.Order(fmt.Sprintf("%v %v", "parent_id", sortByParentId))
	}
	if sortBySort, ok := queryOptions["sortBySort"]; ok {
		query.Order(fmt.Sprintf("%v %v", "sort", sortBySort))
	}
	if count, err := query.Order("id DESC").SelectAndCount(); err != nil {
		return 0, accesss, err
	} else {
		for _, accessModel := range accessModels {
			if access, err := repository.transformPgModelToDomainModel(accessModel); err != nil {
				return 0, accesss, err
			} else {
				accesss = append(accesss, access)
			}
		}
		return int64(count), accesss, nil
	}
}
func (repository *AccessRepository) transformPgModelToDomainModel(accessModel *models.Access) (*domain.Access, error) {
	return &domain.Access{
		Id:         accessModel.Id,
		ParentId:   accessModel.ParentId,
		AccessName: accessModel.AccessName,
		AccessCode: accessModel.AccessCode,
		AccessType: accessModel.AccessType,
		Sort:       accessModel.Sort,
		Object:     accessModel.Object,
		Action:     accessModel.Action,
		Module:     accessModel.Module,
		Icon:       accessModel.Icon,
		Status:     accessModel.Status,
	}, nil
}
func NewAccessRepository(transactionContext *pgTransaction.TransactionContext) (*AccessRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &AccessRepository{
			transactionContext: transactionContext,
		}, nil
	}
}