package repository

import (
	"fmt"

	"github.com/go-pg/pg"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/domain"
	"gitlab.fjmaimaimai.com/linmadan/mmm-worth/pkg/infrastructure/pg/models"
)

type CustomerValueRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

func (repository *CustomerValueRepository) Save(customerValue *domain.CustomerValue) (*domain.CustomerValue, error) {
	tx := repository.transactionContext.PgTx
	if customerValue.Identify() == nil {
		if _, err := tx.QueryOne(
			pg.Scan(&customerValue.CustomerValueId, &customerValue.CustomerValueName, &customerValue.CompanyId),
			"INSERT INTO customer_values (customer_value_name, company_id) VALUES (?, ?) RETURNING id, customer_value_name, company_id",
			customerValue.CustomerValueName, customerValue.CompanyId); err != nil {
			return customerValue, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&customerValue.CustomerValueId, &customerValue.CustomerValueName, &customerValue.CompanyId),
			"UPDATE customer_values SET customer_value_name=?, company_id=? WHERE id=? RETURNING id, customer_value_name, company_id",
			customerValue.CustomerValueName, customerValue.CompanyId, customerValue.Identify()); err != nil {
			return customerValue, err
		}
	}
	return customerValue, nil
}
func (repository *CustomerValueRepository) Remove(customerValue *domain.CustomerValue) (*domain.CustomerValue, error) {
	tx := repository.transactionContext.PgTx
	customerValueModel := new(models.CustomerValue)
	customerValueModel.Id = customerValue.CustomerValueId
	if _, err := tx.Model(customerValueModel).WherePK().Delete(); err != nil {
		return customerValue, err
	}
	return customerValue, nil
}
func (repository *CustomerValueRepository) FindOne(queryOptions map[string]interface{}) (*domain.CustomerValue, error) {
	tx := repository.transactionContext.PgTx
	customerValueModel := new(models.CustomerValue)
	query := tx.Model(customerValueModel)
	if customerValueId, ok := queryOptions["customerValueId"]; ok {
		query = query.Where("customer_value.id = ?", customerValueId)
	}
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if customerValueModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(customerValueModel)
	}
}
func (repository *CustomerValueRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.CustomerValue, error) {
	tx := repository.transactionContext.PgTx
	var customerValueModels []*models.CustomerValue
	customerValues := make([]*domain.CustomerValue, 0)
	query := tx.Model(&customerValueModels)
	if companyId, ok := queryOptions["companyId"]; ok {
		query = query.Where("customer_value.company_id = ?", companyId)
	}
	if customerValueName, ok := queryOptions["customerValueName"]; ok && (customerValueName != "") {
		query = query.Where(`customer_value.customer_value_name = ?`, customerValueName)
	}
	if customerValueNameMatch, ok := queryOptions["customerValueNameMatch"]; ok && (customerValueNameMatch != "") {
		query = query.Where(`customer_value.customer_value_name LIKE ?`, fmt.Sprintf("%%%s%%", customerValueNameMatch.(string)))
	}
	if customerValueIds, ok := queryOptions["customerValueIds"]; ok {
		query = query.Where(`customer_value.id IN (?)`, pg.In(customerValueIds.([]int)))
	}
	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, customerValues, err
	} else {
		for _, customerValueModel := range customerValueModels {
			if customerValue, err := repository.transformPgModelToDomainModel(customerValueModel); err != nil {
				return 0, customerValues, err
			} else {
				customerValues = append(customerValues, customerValue)
			}
		}
		return int64(count), customerValues, nil
	}
}
func (repository *CustomerValueRepository) transformPgModelToDomainModel(customerValueModel *models.CustomerValue) (*domain.CustomerValue, error) {
	return &domain.CustomerValue{
		CustomerValueId:   customerValueModel.Id,
		CustomerValueName: customerValueModel.CustomerValueName,
		CompanyId:         customerValueModel.CompanyId,
	}, nil
}
func NewCustomerValueRepository(transactionContext *pgTransaction.TransactionContext) (*CustomerValueRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &CustomerValueRepository{
			transactionContext: transactionContext,
		}, nil
	}
}