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 _, errInsert := tx.QueryOne(
			pg.Scan(&columnSetting.Id, &columnSetting.CompanyId, &columnSetting.CreatedAt, &columnSetting.Description, &columnSetting.Key, &columnSetting.Uid, &columnSetting.UpdatedAt, &columnSetting.UserName, pg.Array(&columnSetting.Value), pg.Array(&columnSetting.InvalidValue)),
			"INSERT INTO column_settings (column_setting_id, company_id, created_at, description, key, uid, updated_at, user_name, value, invalid_value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING column_setting_id, company_id, created_at, description, key, uid, updated_at, user_name, value, invalid_value",
			columnSetting.Id, columnSetting.CompanyId, columnSetting.CreatedAt, columnSetting.Description, columnSetting.Key, columnSetting.Uid, columnSetting.UpdatedAt, columnSetting.UserName, pg.Array(columnSetting.Value), pg.Array(columnSetting.InvalidValue)); errInsert != nil {
			return columnSetting, errInsert
		}
	} else {
		if _, errUpdate := tx.QueryOne(
			pg.Scan(&columnSetting.Id, &columnSetting.CompanyId, &columnSetting.CreatedAt, &columnSetting.Description, &columnSetting.Key, &columnSetting.Uid, &columnSetting.UpdatedAt, &columnSetting.UserName, pg.Array(&columnSetting.Value), pg.Array(&columnSetting.InvalidValue)),
			"UPDATE column_settings SET column_setting_id=?, company_id=?, created_at=?, description=?, key=?, uid=?, updated_at=?, user_name=?, value=?, invalid_value=? WHERE id=? RETURNING column_setting_id, company_id, created_at, description, key, uid, updated_at, user_name, value, invalid_value",
			columnSetting.Id, columnSetting.CompanyId, columnSetting.CreatedAt, columnSetting.Description, columnSetting.Key, columnSetting.Uid, columnSetting.UpdatedAt, columnSetting.UserName, pg.Array(columnSetting.Value), pg.Array(columnSetting.InvalidValue), columnSetting.Identify()); errUpdate != nil {
			return columnSetting, errUpdate
		}
	}
	return columnSetting, nil
}

func (repository *ColumnSettingRepository) Remove(columnSetting *domain.ColumnSetting, columnSettings []*domain.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, nil, err
	}

	// 批量删除
	var columnSettingModels []*models.ColumnSetting
	for _, setting := range columnSettings {
		columnSettingModels = append(columnSettingModels, &models.ColumnSetting{
			Id: setting.Identify().(int64),
		})
	}
	if _, err := tx.Model(columnSettingModels).WherePK().Delete(); err != nil {
		return nil, columnSettings, err
	}
	return columnSetting, columnSettings, 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 uid, ok := queryOptions["uid"]; ok {
		query = query.Where("column_setting.uid = ?", uid)
	}
	if companyId, ok := queryOptions["companyId"]; ok {
		query = query.Where("column_setting.company_id = ?", companyId)
	}
	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 ids, ok := queryOptions["ids"]; ok {
		query = query.Where("column_setting.uid IN (?)", pg.In(ids.(int)))
	}
	if uid, ok := queryOptions["uid"]; ok {
		query = query.Where("column_setting.uid = ?", uid)
	}
	if companyId, ok := queryOptions["companyId"]; ok {
		query = query.Where("column_setting.company_id = ?", companyId)
	}
	if offset, ok := queryOptions["offset"]; ok {
		queryOffset := offset.(int)
		if queryOffset > -1 {
			query = query.Offset(queryOffset)
		}
	} else {
		query = query.Offset(0)
	}
	if limit, ok := queryOptions["limit"]; ok {
		queryLimit := limit.(int)
		if queryLimit > -1 {
			query = query.Limit(queryLimit)
		}
	} 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, errTrans := repository.transformPgModelToDomainModel(columnSettingModel); errTrans != nil {
				return 0, columnSettings, errTrans
			} 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,        // 有效栏目设置
		InvalidValue: columnSettingModel.InvalidValue, // 无效栏目设置
	}, nil
}

func NewColumnSettingRepository(transactionContext *pgTransaction.TransactionContext) (*ColumnSettingRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &ColumnSettingRepository{
			transactionContext: transactionContext,
		}, nil
	}
}