package ggorm

import (
	"context"

	"gorm.io/gorm"
)

// 进一步封装，K 是主键命，V 是结构体
type DB[K comparable, V any] struct {
	// db
	D *gorm.DB
	// 表名
	T string
	// 主键名
	K string
}

// 初始化
func (m *DB[K, V]) Init(db *gorm.DB, table string, key string) {
	m.D = db
	m.T = table
	m.K = key
}

// 初始化，自动创建表
func (m *DB[K, V]) AutoMigrate(db *gorm.DB, v V, table string, key string) error {
	m.Init(db, table, key)
	return db.AutoMigrate(v)
}

// 主键查询，ptr 是接收数据的结构体指针
func (m *DB[K, V]) Get(ctx context.Context, ptr V, fields ...string) error {
	return First(m.D.WithContext(ctx), ptr, nil, fields...)
}

// 查询第一个，query 是条件struct，ptr 是接收数据的结构体指针
func (m *DB[K, V]) First(ctx context.Context, ptr V, query any, fields ...string) error {
	return First(m.D.WithContext(ctx), ptr, query, fields...)
}

// 查询第一个，query 是条件struct，ptr 是接收数据的结构体指针
func (m *DB[K, V]) FirstAny(ctx context.Context, ptr any, query any, fields ...string) error {
	return First(m.D.WithContext(ctx).Table(m.T), ptr, query, fields...)
}

// 添加
func (m *DB[K, V]) Add(ctx context.Context, v V, fields ...string) error {
	db := Add(m.D.WithContext(ctx), v, fields...)
	return db.Error
}

// 添加，v 是符合表结构的任意结构体或者map
func (m *DB[K, V]) AddAny(ctx context.Context, v any, fields ...string) error {
	db := Add(m.D.WithContext(ctx).Table(m.T), v, fields...)
	return db.Error
}

// 添加
func (m *DB[K, V]) AddOmit(ctx context.Context, v V, fields ...string) error {
	db := AddOmit(m.D.WithContext(ctx), v, fields...)
	return db.Error
}

// 添加，v 是符合表结构的任意结构体或者map
func (m *DB[K, V]) AddAnyOmit(ctx context.Context, v any, fields ...string) error {
	db := AddOmit(m.D.WithContext(ctx).Table(m.T), v, fields...)
	return db.Error
}

// 添加，如果唯一键存在则放弃
func (m *DB[K, V]) AddIgnore(ctx context.Context, v V, fields ...string) error {
	db := AddIgnore(m.D.WithContext(ctx), v, fields...)
	return db.Error
}

// 添加，如果唯一键存在则放弃
func (m *DB[K, V]) AddIgnoreOmit(ctx context.Context, v V, fields ...string) error {
	db := AddIgnoreOmit(m.D.WithContext(ctx), v, fields...)
	return db.Error
}

// 添加，如果唯一键存在则更新指定的字段
func (m *DB[K, V]) AddOrUpdate(ctx context.Context, v V, fields ...string) error {
	db := AddOrUpdate(m.D.WithContext(ctx), v, fields...)
	return db.Error
}

// 批量添加
func (m *DB[K, V]) BatchAdd(ctx context.Context, vs []V, fields ...string) error {
	db := Add(m.D.WithContext(ctx), vs, fields...)
	return db.Error
}

// 批量添加，vs 是符合表结构的任意结构体列表
func (m *DB[K, V]) BatchAddAny(ctx context.Context, vs []any, fields ...string) error {
	db := Add(m.D.WithContext(ctx).Table(m.T), vs, fields...)
	return db.Error
}

// 主键条件更新，不指定字段更新所有
func (m *DB[K, V]) Update(ctx context.Context, v V, fields ...string) (int64, error) {
	db := Update(m.D.WithContext(ctx), v, nil, fields...)
	return db.RowsAffected, db.Error
}

// 更新单个字段
func (m *DB[K, V]) UpdateColumn(ctx context.Context, k K, field string, value any) (int64, error) {
	db := m.D.WithContext(ctx).Table(m.T).Where(m.K, k).UpdateColumn(field, value)
	return db.RowsAffected, db.Error
}

// 更新单个字段
func (m *DB[K, V]) UpdateColumnWhere(ctx context.Context, query any, field string, value any) (int64, error) {
	db := WhereQuery(m.D.WithContext(ctx).Table(m.T), query).UpdateColumn(field, value)
	return db.RowsAffected, db.Error
}

// 更新多个字段
func (m *DB[K, V]) UpdateColumns(ctx context.Context, k K, v map[string]any) (int64, error) {
	db := m.D.WithContext(ctx).Table(m.T).Where(m.K, k).UpdateColumns(v)
	return db.RowsAffected, db.Error
}

// 更新指定字段，v 是符合表结构的任意结构体或者map
func (m *DB[K, V]) UpdateAny(ctx context.Context, k K, v any, fields ...string) (int64, error) {
	db := m.D.WithContext(ctx).Table(m.T).Where(m.K, k)
	if len(fields) > 0 {
		db = db.Select(fields)
	}
	db = db.Updates(v)
	return db.RowsAffected, db.Error
}

// 更新指定字段，v 是符合表结构的任意结构体或者map，query 是条件struct
func (m *DB[K, V]) UpdateAnyWhere(ctx context.Context, v any, query any, fields ...string) (int64, error) {
	db := Update(m.D.WithContext(ctx).Table(m.T), v, query, fields...)
	return db.RowsAffected, db.Error
}

// 事务中批量更新
func (m *DB[K, V]) BatchUpdate(ctx context.Context, vs []V, fields ...string) (int64, error) {
	var row int64
	return row, m.D.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		for _, v := range vs {
			db := Update(tx, v, nil, fields...)
			if db.Error != nil {
				return db.Error
			}
			row += db.RowsAffected
		}
		return nil
	})
}

// 主键删除，k 是主键
func (m *DB[K, V]) Delete(ctx context.Context, k K) (int64, error) {
	db := m.D.WithContext(ctx).Table(m.T).Where(m.K, k).Delete(nil)
	return db.RowsAffected, db.Error
}

// 主键批量删除，k 是主键
func (m *DB[K, V]) BatchDelete(ctx context.Context, ks []K) (int64, error) {
	db := m.D.WithContext(ctx).Table(m.T).Where(m.K, ks).Delete(nil)
	return db.RowsAffected, db.Error
}

// 条件删除，query 是条件struct
func (m *DB[K, V]) DeleteWhere(ctx context.Context, query any) (int64, error) {
	db := WhereQuery(m.D.WithContext(ctx), query).Table(m.T).Delete(nil)
	return db.RowsAffected, db.Error
}

// 分页查询，page是分页，query 是条件，res 是结果，fields 是字段名称
func (m *DB[K, V]) Page(ctx context.Context, page *PageQuery, query any, res *PageResult[V], fields ...string) error {
	db := WhereQuery(m.D.WithContext(ctx).Table(m.T), query)
	return Page(db, page, res, fields...)
}

// 分页查询，page是分页，query 是条件，res 是结果，fields 是字段名称
func (m *DB[K, V]) PageAny(ctx context.Context, page *PageQuery, query any, res *PageResult[any], fields ...string) error {
	db := WhereQuery(m.D.WithContext(ctx).Table(m.T), query)
	return Page(db, page, res, fields...)
}

// 分页查询，page是分页，query 是条件，res 是结果，fields 是忽略的字段名称
func (m *DB[K, V]) PageOmit(ctx context.Context, page *PageQuery, query any, res *PageResult[V], fields ...string) error {
	db := WhereQuery(m.D.WithContext(ctx).Table(m.T), query)
	return PageOmit(db, page, res, fields...)
}

// 查询所有，query 是条件，fields 是字段名称
func (m *DB[K, V]) All(ctx context.Context, query any, fields ...string) ([]V, error) {
	return All[V](m.D.WithContext(ctx).Table(m.T), query, fields...)
}

// 查询所有，query 是条件，fields 是字段名称
func (m *DB[K, V]) AllOrder(ctx context.Context, query any, order string, fields ...string) ([]V, error) {
	return AllOrder[V](m.D.WithContext(ctx).Table(m.T), query, order, fields...)
}

// 查询所有，query 是条件，fields 是忽略的字段名称
func (m *DB[K, V]) AllOmit(ctx context.Context, query any, fields ...string) ([]V, error) {
	return AllOmit[V](m.D.WithContext(ctx).Table(m.T), query, fields...)
}

// 查询所有，query 是条件，fields 是忽略的字段名称
func (m *DB[K, V]) AllOrderOmit(ctx context.Context, query any, order string, fields ...string) ([]V, error) {
	return AllOrderOmit[V](m.D.WithContext(ctx).Table(m.T), query, order, fields...)
}

// 查询单个字段，query 是条件，field 是字段名称，resPtr 是数组指针
func (m *DB[K, V]) Field(ctx context.Context, query any, field string, resPtr any) error {
	db := WhereQuery(m.D.WithContext(ctx).Table(m.T), query)
	return db.Pluck(field, resPtr).Error
}