package repository

import (
	"fmt"
	"github.com/go-pg/pg"
	"gitlab.fjmaimaimai.com/mmm-go/partnermg/pkg/domain"

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

type ColumnSettingRepository struct {
	transactionContext *pgTransaction.TransactionContext
}

func (repository *ColumnSettingRepository) nextIdentify() (int64, error) {
	return 0, nil
}
func (repository *ColumnSettingRepository) Save(columnSetting *domain.ColumnSetting) (*domain.ColumnSetting, error) {
	tx := repository.transactionContext.PgTx
	if columnSetting.Identify() == nil {
		_, err := repository.nextIdentify()
		if err != nil {
			return columnSetting, err
		}
		if _, err := tx.QueryOne(
			pg.Scan(&columnSetting.Id, &columnSetting.CompanyId, &columnSetting.CreatedAt, &columnSetting.Description, &columnSetting.Key, &columnSetting.Uid, &columnSetting.UpdatedAt, &columnSetting.UserName, pg.Array(&columnSetting.Value)),
			"INSERT INTO column_settings (column_setting_id, company_id, created_at, description, key, uid, updated_at, user_name, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING column_setting_id, company_id, created_at, description, key, uid, updated_at, user_name, value",
			columnSetting.Id, columnSetting.CompanyId, columnSetting.CreatedAt, columnSetting.Description, columnSetting.Key, columnSetting.Uid, columnSetting.UpdatedAt, columnSetting.UserName, pg.Array(columnSetting.Value)); err != nil {
			return columnSetting, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&columnSetting.Id, &columnSetting.CompanyId, &columnSetting.CreatedAt, &columnSetting.Description, &columnSetting.Key, &columnSetting.Uid, &columnSetting.UpdatedAt, &columnSetting.UserName, pg.Array(&columnSetting.Value)),
			"UPDATE column_settings SET column_setting_id=?, company_id=?, created_at=?, description=?, key=?, uid=?, updated_at=?, user_name=?, value=? WHERE id=? RETURNING column_setting_id, company_id, created_at, description, key, uid, updated_at, user_name, value",
			columnSetting.Id, columnSetting.CompanyId, columnSetting.CreatedAt, columnSetting.Description, columnSetting.Key, columnSetting.Uid, columnSetting.UpdatedAt, columnSetting.UserName, pg.Array(columnSetting.Value), columnSetting.Identify()); err != nil {
			return columnSetting, err
		}
	}
	return columnSetting, nil
}
func (repository *ColumnSettingRepository) Remove(columnSetting *domain.ColumnSetting) (*domain.ColumnSetting, error) {
	tx := repository.transactionContext.PgTx
	columnSettingModel := new(models.ColumnSetting)
	columnSettingModel.Id = columnSetting.Identify().(int64)
	if _, err := tx.Model(columnSettingModel).WherePK().Delete(); err != nil {
		return columnSetting, err
	}
	return columnSetting, nil
}
func (repository *ColumnSettingRepository) FindOne(queryOptions map[string]interface{}) (*domain.ColumnSetting, error) {
	tx := repository.transactionContext.PgTx
	columnSettingModel := new(models.ColumnSetting)
	query := tx.Model(columnSettingModel)
	if columnSettingId, ok := queryOptions["column_settingId"]; ok {
		query = query.Where("column_setting.id = ?", columnSettingId)
	}
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if columnSettingModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(columnSettingModel)
	}
}
func (repository *ColumnSettingRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.ColumnSetting, error) {
	tx := repository.transactionContext.PgTx
	var columnSettingModels []*models.ColumnSetting
	columnSettings := make([]*domain.ColumnSetting, 0)
	query := tx.Model(&columnSettingModels)
	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, columnSettings, err
	} else {
		for _, columnSettingModel := range columnSettingModels {
			if columnSetting, err := repository.transformPgModelToDomainModel(columnSettingModel); err != nil {
				return 0, columnSettings, err
			} else {
				columnSettings = append(columnSettings, columnSetting)
			}
		}
		return int64(count), columnSettings, nil
	}
}
func (repository *ColumnSettingRepository) transformPgModelToDomainModel(columnSettingModel *models.ColumnSetting) (*domain.ColumnSetting, error) {
	return &domain.ColumnSetting{
		Id:          columnSettingModel.Id,
		CompanyId:   columnSettingModel.CompanyId,
		CreatedAt:   columnSettingModel.CreatedAt,
		Description: columnSettingModel.Description,
		Key:         columnSettingModel.Key,
		Uid:         columnSettingModel.Uid,
		UpdatedAt:   columnSettingModel.UpdatedAt,
		UserName:    columnSettingModel.UserName,
		Value:       columnSettingModel.Value,
	}, nil
}
func NewColumnSettingRepository(transactionContext *pgTransaction.TransactionContext) (*ColumnSettingRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &ColumnSettingRepository{
			transactionContext: transactionContext,
		}, nil
	}
}