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

func (repository *TaskNatureRepository) Save(taskNature *domain.TaskNature) (*domain.TaskNature, error) {
	tx := repository.transactionContext.PgTx
	if taskNature.Identify() == nil {
		if _, err := tx.QueryOne(
			pg.Scan(&taskNature.TaskNatureId, &taskNature.TaskNatureName, &taskNature.CompanyId),
			"INSERT INTO task_natures (task_nature_name, company_id) VALUES (?, ?) RETURNING id, task_nature_name, company_id",
			taskNature.TaskNatureName, taskNature.CompanyId); err != nil {
			return taskNature, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&taskNature.TaskNatureId, &taskNature.TaskNatureName, &taskNature.CompanyId),
			"UPDATE task_natures SET task_nature_name=?, company_id=? WHERE id=? RETURNING id, task_nature_name, company_id",
			taskNature.TaskNatureName, taskNature.CompanyId, taskNature.Identify()); err != nil {
			return taskNature, err
		}
	}
	return taskNature, nil
}

func (repository *TaskNatureRepository) Remove(taskNature *domain.TaskNature) (*domain.TaskNature, error) {
	tx := repository.transactionContext.PgTx
	taskNatureModel := new(models.TaskNature)
	taskNatureModel.Id = taskNature.Identify().(int)
	if _, err := tx.Model(taskNatureModel).WherePK().Delete(); err != nil {
		return taskNature, err
	}
	return taskNature, nil
}

func (repository *TaskNatureRepository) FindOne(queryOptions map[string]interface{}) (*domain.TaskNature, error) {
	tx := repository.transactionContext.PgTx
	taskNatureModel := new(models.TaskNature)
	query := tx.Model(taskNatureModel)
	if taskNatureId, ok := queryOptions["taskNatureId"]; ok {
		query = query.Where("task_nature.id = ?", taskNatureId)
	}
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if taskNatureModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(taskNatureModel)
	}
}

func (repository *TaskNatureRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.TaskNature, error) {
	tx := repository.transactionContext.PgTx
	var taskNatureModels []*models.TaskNature
	taskNatures := make([]*domain.TaskNature, 0)
	query := tx.Model(&taskNatureModels)
	if companyId, ok := queryOptions["companyId"]; ok {
		query = query.Where("task_nature.company_id = ?", companyId)
	}
	if taskNatureName, ok := queryOptions["taskNatureName"]; ok && (taskNatureName != "") {
		query = query.Where(`task_nature.task_nature_name = ?`, taskNatureName)
	}
	if taskNatureNameMatch, ok := queryOptions["taskNatureNameMatch"]; ok && (taskNatureNameMatch != "") {
		query = query.Where(`task_nature.task_nature_name LIKE ?`, fmt.Sprintf("%%%s%%", taskNatureNameMatch.(string)))
	}
	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, taskNatures, err
	} else {
		for _, taskNatureModel := range taskNatureModels {
			if taskNature, err := repository.transformPgModelToDomainModel(taskNatureModel); err != nil {
				return 0, taskNatures, err
			} else {
				taskNatures = append(taskNatures, taskNature)
			}
		}
		return int64(count), taskNatures, nil
	}
}

func (repository *TaskNatureRepository) transformPgModelToDomainModel(taskNatureModel *models.TaskNature) (*domain.TaskNature, error) {
	return &domain.TaskNature{
		TaskNatureId:   taskNatureModel.Id,
		TaskNatureName: taskNatureModel.TaskNatureName,
		CompanyId:      taskNatureModel.CompanyId,
	}, nil
}

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