package webfilesystem

import (
	"context"
	"errors"
	"strings"

	"github.com/mitchellh/mapstructure"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
)

type WebFileSystem struct {
	webfsCollection *mongo.Collection
	// folders []*Folder
}

func NewWebFileSystem(mongoClient *mongo.Client, dBName string, fsCollectionName string) *WebFileSystem {
	return &WebFileSystem{
		webfsCollection: mongoClient.Database(dBName).Collection(fsCollectionName), // TODO Check collection is exist
	}
}

func (fs *WebFileSystem) Read(path string) (*WebFSFile, error) {
	splittedPath := fs.SplitPath(path)
	filter := primitive.D{
		{
			Key:   "name",
			Value: splittedPath[len(splittedPath)-1],
		},
	}
	file, err := fs.findFileInMongo(filter)
	return file, err
}

func (fs *WebFileSystem) ReadByObjectID(objectId primitive.ObjectID) (*WebFSFile, error) {
	filter := primitive.D{
		{
			Key:   "_id",
			Value: objectId,
		},
	}
	file, err := fs.findFileInMongo(filter)
	return file, err
}

func (fs *WebFileSystem) findFileInMongo(filter primitive.D) (*WebFSFile, error) {
	res := fs.webfsCollection.FindOne(context.Background(), &filter)
	file := WebFSFile{}
	err := res.Decode(&file)
	if err != nil {
		return nil, err
	}
	return &file, nil
}

func (fs *WebFileSystem) List(path string) ([]*WebFSFile, error) {
	dirFile, err := fs.Read(fs.GetParentPath(path))
	if err != nil {
		return nil, err
	}
	if dirFile.Type != "directory" {
		return nil, errors.New("file is not a directory")
	}
	fileData := FolderData{}
	err = mapstructure.Decode(dirFile.Data.(primitive.D).Map(), &fileData)
	if err != nil {
		return nil, err
	}

	files := []*WebFSFile{}
	for _, child := range fileData.Children {
		file, err := fs.ReadByObjectID(child)
		if err != nil {
			println(err.Error())
			continue
		}
		files = append(files, file)
	}
	return files, nil
}

func (fs *WebFileSystem) CreateDirectory(path string) error {
	splittedpath := fs.SplitPath(path)
	directory := WebFSFile{
		MongoId: primitive.NewObjectID(),
		Name:    splittedpath[len(splittedpath)-1],
		Type:    "directory",
		Data: FolderData{
			// Parent: ,
			Children: []primitive.ObjectID{
				primitive.NewObjectID(),
				primitive.NewObjectID(),
				primitive.NewObjectID(),
			},
		},
	}
	_, err := fs.webfsCollection.InsertOne(context.Background(), &directory)
	if err != nil {
		return err
	}
	// res.InsertedID //TODO Insert to parent folder data
	return nil
}

func (fs *WebFileSystem) SplitPath(path string) []string {
	resPath := []string{}
	splittedPath := strings.Split(path, "/")
	splittedPath[0] = "/"
	for _, split := range splittedPath {
		if split != "" {
			resPath = append(resPath, split)
		}
	}
	return resPath
}

func (fs *WebFileSystem) GetParentPath(path string) string {
	splittedPath := fs.SplitPath(path)
	parentPath := strings.Join(splittedPath[:len(splittedPath)-1], "/")
	return parentPath
}

type WebFSFile struct {
	MongoId primitive.ObjectID `bson:"_id"  json:"-"`
	Name    string             `bson:"name" json:"name"`
	Type    string             `bson:"type" json:"type"`
	Data    interface{}        `bson:"data" json:"-"`
}

type FolderData struct {
	Parent   primitive.ObjectID   `bson:"parent"`
	Children []primitive.ObjectID `bson:"children"`
}

type File interface {
	GetUuid() string
	GetFileName() string
}

type Image struct {
}

type Exec struct {
	WebFSFile
}

// func (e *Exec) GetUuid() string {
// 	return e.Id
// }

func (e *Exec) GetFileName() string {
	return e.Name
}