package model

import (
	"context"
	"gorm.io/gorm"
	"yx-dataset-server/app/errors"
	"yx-dataset-server/app/model/entity"
	"yx-dataset-server/app/schema"
)

// NewDatasetFile 创建DatasetFile存储实例
func NewDatasetFile(db *gorm.DB) *DatasetFile {
	return &DatasetFile{db}
}

// DatasetFile DatasetFile存储
type DatasetFile struct {
	db *gorm.DB
}

func (a *DatasetFile) getQueryOption(opts ...schema.DatasetFileQueryOptions) schema.DatasetFileQueryOptions {
	var opt schema.DatasetFileQueryOptions
	if len(opts) > 0 {
		opt = opts[0]
	}
	return opt
}

// Query 查询数据
func (a *DatasetFile) Query(ctx context.Context, params schema.DatasetFileQueryParam, opts ...schema.DatasetFileQueryOptions) (*schema.DatasetFileQueryResult, error) {
	db := entity.GetDatasetFileDB(ctx, a.db)
	if v := params.DatasetId; v != "" {
		db = db.Where("dataset_id=?", v)
	}
	if v := params.RecordIDs; len(v) > 0 {
		db = db.Where("record_id in (?)", v)
	}
	if v := params.DatasetId; len(v) > 0 {
		db = db.Where("dataset_id in (?)", v)
	}
	db = db.Order("id DESC")

	opt := a.getQueryOption(opts...)
	var list entity.DatasetFiles
	pr, err := WrapPageQuery(ctx, db, opt.PageParam, &list)
	if err != nil {
		return nil, errors.ErrDBServerInternalError
	}
	qr := &schema.DatasetFileQueryResult{
		PageResult: pr,
		Data:       list.ToSchemaDatasetFiles(),
	}

	return qr, nil
}

// Get 查询指定数据
func (a *DatasetFile) Get(ctx context.Context, recordID string, opts ...schema.DatasetFileQueryOptions) (*schema.DatasetFile, error) {
	db := entity.GetDatasetFileDB(ctx, a.db).Where("record_id=?", recordID)
	var item entity.DatasetFile
	ok, err := FindOne(ctx, db, &item)
	if err != nil {
		return nil, errors.ErrDBServerInternalError
	} else if !ok {
		return nil, nil
	}

	return item.ToSchemaDatasetFile(), nil
}

// Create 创建数据
func (a *DatasetFile) Create(ctx context.Context, item schema.DatasetFile) error {
	DatasetFile := entity.SchemaDatasetFile(item).ToDatasetFile()
	result := entity.GetDatasetFileDB(ctx, a.db).Create(DatasetFile)
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}

// Update 更新数据
func (a *DatasetFile) Update(ctx context.Context, recordID string, item schema.DatasetFile) error {
	DatasetFile := entity.SchemaDatasetFile(item).ToDatasetFile()
	result := entity.GetDatasetFileDB(ctx, a.db).Where("record_id=?", recordID).Omit("record_id", "creator").Updates(DatasetFile)
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}

// Delete 删除数据
func (a *DatasetFile) Delete(ctx context.Context, recordID string) error {
	result := entity.GetDatasetFileDB(ctx, a.db).Where("record_id=?", recordID).Delete(entity.DatasetFile{})
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}

// BatchDelete 删除数据
func (a *DatasetFile) BatchDelete(ctx context.Context, recordIDs []string) error {
	result := entity.GetDatasetFileDB(ctx, a.db).Where("record_id in (?)", recordIDs).Delete(entity.DatasetFile{})
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}

// DeleteByDatasetId 删除数据
func (a *DatasetFile) DeleteByDatasetIds(ctx context.Context, datasetIds []string) error {
	result := entity.GetDatasetFileDB(ctx, a.db).Where("dataset_id in (?)", datasetIds).Delete(entity.DatasetFile{})
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}

// UpdateStatus 更新状态
func (a *DatasetFile) UpdateStatus(ctx context.Context, recordID string, status int) error {
	result := entity.GetDatasetFileDB(ctx, a.db).Where("record_id=?", recordID).Update("status", status)
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}

// UpdateParseStatus 更新解析状态
func (a *DatasetFile) UpdateParseStatus(ctx context.Context, recordID string, status int) error {
	result := entity.GetDatasetFileDB(ctx, a.db).Where("record_id = ?", recordID).Update("parse_status", status)
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}

// UpdateEnabled 更新启用状态
func (a *DatasetFile) UpdateEnabled(ctx context.Context, recordID string, status bool) error {
	result := entity.GetDatasetFileDB(ctx, a.db).Where("record_id=?", recordID).Update("enabled", status)
	if err := result.Error; err != nil {
		return errors.ErrDBServerInternalError
	}
	return nil
}
