package repository

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

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

type ColumnSettingRepository struct {
	transactionContext *transaction.TransactionContext
}

//func (repository *ColumnSettingRepository) nextIdentify() (int64, error) {
//	return 0, nil
//}

func (repository *ColumnSettingRepository) Save(columnSetting *domain.ColumnSetting) (*domain.ColumnSetting, error) {
	tx := repository.transactionContext.PgTx

	columnSettingModel := &models.ColumnSetting{
		Id:           columnSetting.Id,
		CompanyId:    columnSetting.CompanyId,
		CreatedAt:    columnSetting.CreatedAt,
		Description:  columnSetting.Description,
		Key:          columnSetting.Key,
		Uid:          columnSetting.Uid,
		UpdatedAt:    columnSetting.UpdatedAt,
		UserName:     columnSetting.UserName,
		Value:        columnSetting.Value,
		InvalidValue: columnSetting.InvalidValue,
	}

	if columnSetting.Identify() == nil {
		_, err := tx.Model(columnSettingModel).Insert()
		if err != nil {
			return nil, err
		}
		//_, 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 (company_id, created_at, description, key, uid, updated_at, user_name, value, invalid_value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id, company_id, created_at, description, key, uid, updated_at, user_name, value, invalid_value",
		//	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 company_id=?, created_at=?, description=?, key=?, uid=?, updated_at=?, user_name=?, value=?, invalid_value=? WHERE id=? RETURNING id, company_id, created_at, description, key, uid, updated_at, user_name, value, invalid_value",
		//	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
		//}
		_, err := tx.Model(columnSettingModel).WherePK().
			Column("company_id", "created_at", "description", "key", "uid", "updated_at", "user_name", "value", "invalid_value").Update()
		if err != nil {
			return nil, err
		}
	}
	return columnSetting, nil
}

func (repository *ColumnSettingRepository) Remove(columnSetting *domain.ColumnSetting, columnSettings []*domain.ColumnSetting) (*domain.ColumnSetting, []*domain.ColumnSetting, error) {
	tx := repository.transactionContext.PgTx

	// 单个删除
	if columnSetting != nil {
		columnSettingModel := new(models.ColumnSetting)
		columnSettingModel.Id = columnSetting.Identify().(int64)
		if _, err := tx.Model(columnSettingModel).WherePK().Delete(); err != nil {
			return columnSetting, nil, err
		}
	}

	// 批量删除
	if len(columnSettings) > 0 {
		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 domain.ColumnSettingFindQuery) (int64, []*domain.ColumnSetting, error) {
	tx := repository.transactionContext.PgTx
	var columnSettingModels []*models.ColumnSetting
	columnSettings := make([]*domain.ColumnSetting, 0)
	query := tx.Model(&columnSettingModels)
	if len(queryOptions.Ids) > 0 {
		query = query.Where("column_setting.uid IN (?)", pg.In(queryOptions.Ids))
	}
	if queryOptions.Uid > 0 {
		query = query.Where("column_setting.uid = ?", queryOptions.Uid)
	}
	if queryOptions.CompanyId > 0 {
		query = query.Where("column_setting.company_id = ?", queryOptions.CompanyId)
	}
	if queryOptions.Offset > -1 {
		query = query.Offset(queryOptions.Offset)
	}
	if queryOptions.Limit > 0 {
		query = query.Limit(queryOptions.Limit)
	} else {
		query = query.Limit(20)
	}
	//if ids, ok := queryOptions["ids"]; ok && len(ids.([]int64)) != 0 {
	//	query = query.Where("column_setting.uid in(?)", ids)
	//}
	//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 *transaction.TransactionContext) (*ColumnSettingRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &ColumnSettingRepository{
			transactionContext: transactionContext,
		}, nil
	}
}