package repository

import (
	"fmt"
	"github.com/linmadan/egglib-go/utils/snowflake"

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

func (repository *NotificationRepository) nextIdentify() (int64, error) {
	IdWorker, err := snowflake.NewIdWorker(2)
	if err != nil {
		return 0, err
	}
	id, err := IdWorker.NextId()
	return id, err
}

func (repository *NotificationRepository) Save(notification *domain.Notification) (*domain.Notification, error) {
	tx := repository.transactionContext.PgTx
	if notification.Identify() == nil {
		if nextId, err := repository.nextIdentify(); err != nil {
			return notification, err
		} else {
			notification.NotificationId = nextId
		}
		if _, err := tx.QueryOne(
			pg.Scan(&notification.NotificationId, &notification.NotificationType, &notification.NotificationTitle, &notification.NotificationContent, &notification.NotificationTime, &notification.ExternalResourceType, &notification.ExternalResource),
			"INSERT INTO notifications (id, notification_type, notification_title, notification_content, notification_time, external_resource_type, external_resource) VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id, notification_type, notification_title, notification_content, notification_time, external_resource_type, external_resource",
			notification.NotificationId, notification.NotificationType, notification.NotificationTitle, notification.NotificationContent, notification.NotificationTime, notification.ExternalResourceType, notification.ExternalResource); err != nil {
			return notification, err
		}
	} else {
		if _, err := tx.QueryOne(
			pg.Scan(&notification.NotificationType, &notification.NotificationTitle, &notification.NotificationContent, &notification.NotificationTime, &notification.ExternalResourceType, &notification.ExternalResource),
			"UPDATE notifications SET notification_type=?, notification_title=?, notification_content=?, notification_time=?, external_resource_type=?, external_resource=? WHERE id=? RETURNING notification_type, notification_title, notification_content, notification_time, external_resource_type, external_resource",
			notification.NotificationType, notification.NotificationTitle, notification.NotificationContent, notification.NotificationTime, notification.ExternalResourceType, notification.ExternalResource, notification.Identify()); err != nil {
			return notification, err
		}
	}
	return notification, nil
}
func (repository *NotificationRepository) Remove(notification *domain.Notification) (*domain.Notification, error) {
	tx := repository.transactionContext.PgTx
	notificationModel := new(models.Notification)
	notificationModel.Id = notification.Identify().(int64)
	if _, err := tx.Model(notificationModel).WherePK().Delete(); err != nil {
		return notification, err
	}
	return notification, nil
}
func (repository *NotificationRepository) FindOne(queryOptions map[string]interface{}) (*domain.Notification, error) {
	tx := repository.transactionContext.PgTx
	notificationModel := new(models.Notification)
	query := tx.Model(notificationModel)
	if notificationId, ok := queryOptions["notificationId"]; ok {
		query = query.Where("notification.id = ?", notificationId)
	}
	if err := query.First(); err != nil {
		if err.Error() == "pg: no rows in result set" {
			return nil, fmt.Errorf("没有此资源")
		} else {
			return nil, err
		}
	}
	if notificationModel.Id == 0 {
		return nil, nil
	} else {
		return repository.transformPgModelToDomainModel(notificationModel)
	}
}
func (repository *NotificationRepository) Find(queryOptions map[string]interface{}) (int64, []*domain.Notification, error) {
	tx := repository.transactionContext.PgTx
	var notificationModels []*models.Notification
	notifications := make([]*domain.Notification, 0)
	query := tx.Model(&notificationModels)
	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, notifications, err
	} else {
		for _, notificationModel := range notificationModels {
			if notification, err := repository.transformPgModelToDomainModel(notificationModel); err != nil {
				return 0, notifications, err
			} else {
				notifications = append(notifications, notification)
			}
		}
		return int64(count), notifications, nil
	}
}
func (repository *NotificationRepository) transformPgModelToDomainModel(notificationModel *models.Notification) (*domain.Notification, error) {
	return &domain.Notification{
		NotificationId:       notificationModel.Id,
		NotificationType:     notificationModel.NotificationType,
		NotificationTitle:    notificationModel.NotificationTitle,
		NotificationContent:  notificationModel.NotificationContent,
		NotificationTime:     notificationModel.NotificationTime,
		ExternalResourceType: notificationModel.ExternalResourceType,
		ExternalResource:     notificationModel.ExternalResource,
	}, nil
}
func NewNotificationRepository(transactionContext *pgTransaction.TransactionContext) (*NotificationRepository, error) {
	if transactionContext == nil {
		return nil, fmt.Errorf("transactionContext参数不能为nil")
	} else {
		return &NotificationRepository{
			transactionContext: transactionContext,
		}, nil
	}
}