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 ClientVersionRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

func (repository *ClientVersionRepository) nextIdentify() (int64, error) {
	return 0, nil
}
func (repository *ClientVersionRepository) Save(clientVersion *domain.ClientVersion) (*domain.ClientVersion, error) {
	tx := repository.transactionContext.PgTx
	if clientVersion.Identify() == nil {
		_, err := repository.nextIdentify()
		if err != nil {
			return clientVersion, err
		}
		if _, err := tx.QueryOne(
			pg.Scan(&clientVersion.Id, &clientVersion.Commiter, &clientVersion.ProjectName, &clientVersion.Version, &clientVersion.Title, &clientVersion.Remark, pg.Array(&clientVersion.ClientPackageInfo), &clientVersion.CreateTime),
			"INSERT INTO client_versions (id, commiter, project_name, version, title, remark, client_package_info, create_time) VALUES (?, ?, ?, ?, ?, ?, ?, ?) RETURNING id, commiter, project_name, version, title, remark, client_package_info, create_time",
			clientVersion.Id, clientVersion.Commiter, clientVersion.ProjectName, clientVersion.Version, clientVersion.Title, clientVersion.Remark, pg.Array(clientVersion.ClientPackageInfo), clientVersion.CreateTime); err != nil {
			return clientVersion, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&clientVersion.Id, &clientVersion.Commiter, &clientVersion.ProjectName, &clientVersion.Version, &clientVersion.Title, &clientVersion.Remark, pg.Array(&clientVersion.ClientPackageInfo), &clientVersion.CreateTime),
			"UPDATE client_versions SET id=?, commiter=?, project_name=?, version=?, title=?, remark=?, client_package_info=?, create_time=? WHERE id=? RETURNING id, commiter, project_name, version, title, remark, client_package_info, create_time",
			clientVersion.Id, clientVersion.Commiter, clientVersion.ProjectName, clientVersion.Version, clientVersion.Title, clientVersion.Remark, pg.Array(clientVersion.ClientPackageInfo), clientVersion.CreateTime, clientVersion.Identify()); err != nil {
			return clientVersion, err
		}
	}
	return clientVersion, nil
}
func (repository *ClientVersionRepository) Remove(clientVersion *domain.ClientVersion) (*domain.ClientVersion, error) {
	tx := repository.transactionContext.PgTx
	clientVersionModel := new(models.ClientVersion)
	clientVersionModel.Id = clientVersion.Identify().(int64)
	if _, err := tx.Model(clientVersionModel).WherePK().Delete(); err != nil {
		return clientVersion, err
	}
	return clientVersion, nil
}
func (repository *ClientVersionRepository) FindOne(queryOptions map[string]interface{}) (*domain.ClientVersion, error) {
	tx := repository.transactionContext.PgTx
	clientVersionModel := new(models.ClientVersion)
	query := tx.Model(clientVersionModel)
	if clientVersionId, ok := queryOptions["clientVersionId"]; ok {
		query = query.Where("client_version.id = ?", clientVersionId)
	}
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if clientVersionModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(clientVersionModel)
	}
}
func (repository *ClientVersionRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.ClientVersion, error) {
	tx := repository.transactionContext.PgTx
	var clientVersionModels []*models.ClientVersion
	clientVersions := make([]*domain.ClientVersion, 0)
	query := tx.Model(&clientVersionModels)
	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 count, err := query.Order("id DESC").SelectAndCount(); err != nil {
		return 0, clientVersions, err
	} else {
		for _, clientVersionModel := range clientVersionModels {
			if clientVersion, err := repository.transformPgModelToDomainModel(clientVersionModel); err != nil {
				return 0, clientVersions, err
			} else {
				clientVersions = append(clientVersions, clientVersion)
			}
		}
		return int64(count), clientVersions, nil
	}
}
func (repository *ClientVersionRepository) transformPgModelToDomainModel(clientVersionModel *models.ClientVersion) (*domain.ClientVersion, error) {
	return &domain.ClientVersion{
		Id:                clientVersionModel.Id,
		Commiter:          clientVersionModel.Commiter,
		ProjectName:       clientVersionModel.ProjectName,
		Version:           clientVersionModel.Version,
		Title:             clientVersionModel.Title,
		Remark:            clientVersionModel.Remark,
		ClientPackageInfo: clientVersionModel.ClientPackageInfo,
		CreateTime:        clientVersionModel.CreateTime,
	}, nil
}
func NewClientVersionRepository(transactionContext *pgTransaction.TransactionContext) (*ClientVersionRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &ClientVersionRepository{
			transactionContext: transactionContext,
		}, nil
	}
}