package dao

import (
	"bufio"
	"context"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"time"

	"github.com/willie68/schematic-service-go/config"
	slicesutils "github.com/willie68/schematic-service-go/internal"
	"github.com/willie68/schematic-service-go/model"

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

const timeout = 1 * time.Minute

var client *mongo.Client
var mongoConfig config.MongoDB
var bucket gridfs.Bucket
var database mongo.Database

func InitDB(MongoConfig config.MongoDB) {
	mongoConfig = MongoConfig
	//	uri := fmt.Sprintf("mongodb://%s:%s@%s:%d", mongoConfig.Username, mongoConfig.Password, mongoConfig.Host, mongoConfig.Port)
	uri := fmt.Sprintf("mongodb://%s:%d", mongoConfig.Host, mongoConfig.Port)
	clientOptions := options.Client()
	clientOptions.ApplyURI(uri)
	clientOptions.Auth = &options.Credential{Username: mongoConfig.Username, Password: mongoConfig.Password, AuthSource: mongoConfig.AuthDB}
	var err error
	client, err = mongo.NewClient(clientOptions)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
	}
	ctx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()
	err = client.Connect(ctx)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
	}
	database = *client.Database(mongoConfig.Database)

	myBucket, err := gridfs.NewBucket(&database, options.GridFSBucket().SetName("attachment"))
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
	}
	bucket = *myBucket

	initIndex()
}

func initIndex() {
	collection := database.Collection("schematic")
	indexView := collection.Indexes()
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	cursor, err := indexView.List(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer cursor.Close(ctx)
	myIndexes := make([]string, 0)
	for cursor.Next(ctx) {
		var index bson.M
		if err = cursor.Decode(&index); err != nil {
			log.Fatal(err)
		}
		myIndexes = append(myIndexes, index["name"].(string))
	}

	for _, name := range myIndexes {
		log.Println(name)
	}
	if !slicesutils.Contains(myIndexes, "manufaturer") {
		ctx, _ = context.WithTimeout(context.Background(), timeout)
		models := []mongo.IndexModel{
			{
				Keys:    bson.D{{"manufacturer", 1}},
				Options: options.Index().SetName("manufacturer").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
			},
			{
				Keys:    bson.D{{"model", 1}},
				Options: options.Index().SetName("model").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
			},
			{
				Keys:    bson.D{{"tags", 1}},
				Options: options.Index().SetName("tags").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
			},
			{
				Keys:    bson.D{{"subtitle", 1}},
				Options: options.Index().SetName("subtitle").SetCollation(&options.Collation{Locale: "en", Strength: 2}),
			},
		}

		// Specify the MaxTime option to limit the amount of time the operation can run on the server
		opts := options.CreateIndexes().SetMaxTime(2 * time.Second)
		names, err := indexView.CreateMany(context.TODO(), models, opts)
		if err != nil {
			log.Fatal(err)
		}
		for _, name := range names {
			log.Println(name)
		}
	}
	/*
	   	db.collection.createIndex( { "key" : 1 },
	                              { collation: {
	                                  locale : <locale>,
	                                  strength : <strength>
	                                }
	                              } )
	*/
}

func AddFile(File string) (string, error) {
	filename := filepath.Base(File)
	uploadOpts := options.GridFSUpload().SetMetadata(bson.D{{"tag", "tag"}})

	f, err := os.Open(File)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return "", err
	}
	defer f.Close()
	reader := bufio.NewReader(f)

	fileID, err := bucket.UploadFromStream(filename, reader, uploadOpts)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return "", err
	}
	log.Printf("Write file to DB was successful. File id: %s \n", fileID)
	id := fileID.String()
	return id, nil
}

func CreateSchematic(schematic model.Schematic) (string, error) {
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	collection := database.Collection("schematic")
	result, err := collection.InsertOne(ctx, schematic)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return "", err
	}
	filter := bson.M{"_id": result.InsertedID}
	err = collection.FindOne(ctx, filter).Decode(&schematic)
	if err != nil {
		fmt.Printf("error: %s\n", err.Error())
		return "", err
	}
	return result.InsertedID.(string), nil
}