package mongo

import (
	"context"
	"encoding/json"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

const (
	dbevent string = "event"
	tbevent string = "event"
)

const (
	EventStatusHappen = iota
	EventStatusDataAt
	EventStatusReport
	EventStatusConfirm
	EventStatusPersist
	EventStatusClose
)

const (
	EventActionHappened = "happened"
)

type operation struct {
	Action string `bson:"action" json:"action"`
	OP     string `bson:"op" json:"op"`
	TS     int64  `bson:"ts" json:"ts"`
}

type Event struct {
	Event      string       `bson:"event" json:"event"`
	EventUUID  string       `bson:"event_uuid" json:"event_uuid"`
	Type       int          `bson:"type" json:"type"`
	Priority   int          `bson:"priority" json:"priority"` // 0~9
	Status     int          `bson:"status" json:"status"`
	Timestamp  int64        `bson:"timestamp" json:"timestamp"`
	From       string       `bson:"from" json:"from"`
	Operations []*operation `bson:"operations" json:"operations"`
	// TODO complete
	Alarm *Alarm `bson:"alarm" json:"alarm"`
}

func (e *Event) Marshall() ([]byte, error) {
	return json.Marshal(e)
}

func InsertOneEvent(ctx context.Context, doc *Event) error {
	_, err := getCollection(dbevent, tbevent).InsertOne(ctx, doc)
	return err
}

func InsertEvents(ctx context.Context, docs []*Event) error {
	_, err := getCollection(dbevent, tbevent).InsertMany(ctx, docs)
	return err
}

func DeleteOneEvent[T bson.M | *bson.D](ctx context.Context, filter T) error {
	_, err := getCollection(dbevent, tbevent).DeleteOne(ctx, filter)
	return err
}

func DeleteEvents[T bson.M | *bson.D](ctx context.Context, filter T) error {
	_, err := getCollection(dbevent, tbevent).DeleteMany(ctx, filter)
	return err
}

// insert if not update
func UpdateOneEvent[T bson.M | *bson.D](ctx context.Context, filter T, update T) error {
	opts := options.UpdateOne().SetUpsert(true)
	_, err := getCollection(dbevent, tbevent).UpdateOne(ctx, filter, update, opts)
	return err
}

// insert if not update
func UpdateEvents[T bson.M | *bson.D](ctx context.Context, filter T, update T) error {
	opts := options.UpdateMany().SetUpsert(true)
	_, err := getCollection(dbevent, tbevent).UpdateMany(ctx, filter, update, opts)
	return err
}

func FindOneEvent[T bson.M | *bson.D](ctx context.Context, filter T) (*Event, error) {
	doc := new(Event)
	err := getCollection(dbevent, tbevent).FindOne(ctx, filter).Decode(doc)
	// if errors.Is(err, mongo.ErrNoDocuments) {
	// 	return nil, nil
	// }
	if err != nil {
		return nil, err
	}

	return doc, nil
}

func FindEvents[T bson.M | *bson.D](ctx context.Context, filter T) ([]*Event, error) {
	cursor, err := getCollection(dbevent, tbevent).Find(ctx, filter)
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

	var docs []*Event
	if err = cursor.All(ctx, &docs); err != nil {
		return nil, err
	}

	return docs, nil
}

func FindEventsInBatch[T bson.M | *bson.D](ctx context.Context, filter T,
	batchSize int32) ([]*Event, error) {

	opt := options.Find().SetBatchSize(batchSize)
	cursor, err := getCollection(dbevent, tbevent).Find(ctx, filter, opt)
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

	var docs []*Event
	for cursor.Next(ctx) {
		doc := new(Event)
		if err = cursor.Decode(doc); err != nil {
			return nil, err
		}
		docs = append(docs, doc)
	}

	return docs, nil
}

func FindEventsWithPageLimit[T bson.M | *bson.D](ctx context.Context, filter T,
	sort int, page int64, limit int64) ([]*Event, error) {
	// TODO
	opt := options.Find().SetSort(bson.D{{Key: "timestamp", Value: sort}}).
		SetSkip(limit * (page - 1)).SetLimit(limit)

	cursor, err := getCollection(dbevent, tbevent).Find(ctx, filter, opt)
	if err != nil {
		return nil, err
	}
	defer cursor.Close(ctx)

	var docs []*Event
	for cursor.Next(ctx) {
		doc := new(Event)
		if err := cursor.Decode(doc); err != nil {
			return nil, err
		}
		docs = append(docs, doc)
	}

	return docs, nil
}

// sys: 0-hard/1-platform/2-application
//
// level:1-info/2-warn/3-error
func genEventType(sys int, level int) int {
	return sys + level*3
}