package webfilesystem

import (
	"context"
	"errors"
	"net/http"
	"strconv"
	"strings"

	"github.com/gin-gonic/gin"
	"github.com/mitchellh/mapstructure"
	"go.mongodb.org/mongo-driver/bson"
	"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))
	dirFile, err := fs.Read(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)
	parentPath := fs.GetParentPath(path)
	parentDir, err := fs.Read(parentPath)
	if err != nil {
		return err
	}
	directory := WebFSFile{
		MongoId: primitive.NewObjectID(),
		Name:    splittedpath[len(splittedpath)-1],
		Type:    "directory",
		Data: FolderData{
			Parent:   parentDir.MongoId,
			Children: []primitive.ObjectID{},
		},
	}

	fs.CreateFile(&directory, parentPath)
	// res, err := fs.webfsCollection.InsertOne(context.Background(), &directory) //TODO
	// if err != nil {
	// 	return err
	// }

	// fileId := fs.castInsertId(res)
	// fs.insertFileToDirectory(fileId, parentDir.MongoId)
	return nil
}

func (fs *WebFileSystem) UpdateFile(filePath string, update primitive.M) error {
	file, err := fs.Read(filePath)
	if err != nil {
		return err
	}

	if file.MongoId.IsZero() {
		return errors.New("mongo id is zero")
	}
	filter := primitive.M{
		"_id": file.MongoId,
	}

	_, err = fs.webfsCollection.UpdateOne(context.Background(), filter, primitive.M{"$set": update})
	if err != nil {
		return err
	}
	return nil

}

func (fs *WebFileSystem) CreateFile(file *WebFSFile, parentPath string) error {
	//TODO Check file existance
	parentDir, err := fs.Read(parentPath)
	if err != nil {
		return err
	}
	res, err := fs.webfsCollection.InsertOne(context.Background(), &file)
	if err != nil {
		return err
	}
	_ = parentDir
	fileId := fs.castInsertId(res)
	fs.insertFileToDirectory(fileId, parentDir.MongoId)
	return nil
}

func (fs *WebFileSystem) castInsertId(res *mongo.InsertOneResult) primitive.ObjectID {
	return res.InsertedID.(primitive.ObjectID)
}

func (fs *WebFileSystem) insertFileToDirectory(fileId primitive.ObjectID, directoryId primitive.ObjectID) error {
	dir, err := fs.ReadByObjectID(directoryId)
	if err != nil {
		return err
	}
	//TODO check if file exist
	fileData := FolderData{}
	err = mapstructure.Decode(dir.Data.(primitive.D).Map(), &fileData)
	if err != nil {
		return err
	}
	fileData.Children = append(fileData.Children, fileId)

	fs.webfsCollection.UpdateByID(context.Background(), directoryId, bson.M{"$set": bson.M{"data": fileData}})
	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) GetExtension(filename string) string {
	// extension := []string{}
	splittedName := strings.Split(filename, ".")

	return splittedName[len(splittedName)-1]
}

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

func (fs *WebFileSystem) Delete(filePath string) error {
	splittedPath := fs.SplitPath(filePath)
	parentPath := strings.Join(splittedPath[:len(splittedPath)-1], "/")

	file, err := fs.Read(filePath)
	if err != nil {
		return err
	}

	parentDir, err := fs.Read(parentPath)
	if err != nil {
		return err
	}

	parentDir.Data.(primitive.D).Map()

	// update:= primitive.M{
	// 	"data.children":
	// }
	// filter := primitive.M{}
	res, err := fs.webfsCollection.UpdateByID(context.Background(), parentDir.MongoId, primitive.M{"$unset": bson.M{"data.children." + file.MongoId.String(): ""}})
	// res, err := fs.webfsCollection.UpdateOne(context.Background(), filter, primitive.M{"$unset": bson.M{"data.children." + file.MongoId.String(): ""}})
	if err != nil {
		return err
	}
	if res.MatchedCount < 1 {
		return errors.New("no documents found")
	}
	return nil
}

func (fs *WebFileSystem) Route(route *gin.RouterGroup) {
	route.POST("/upload", func(ctx *gin.Context) { //TODO To PUT request
		// fileName := ctx.Query("fileName")
		// if fileName == "" {
		// 	ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
		// 	return
		// }
		path := ctx.Query("path")
		if path == "" {
			ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
			return
		}
		// single file
		file, _ := ctx.FormFile("file")
		if file == nil {
			ctx.String(http.StatusBadRequest, "file is nil")
			return
		}
		// generateMins := c.Param("generateMins")
		// log.Println(file.Filename)

		// Upload the file to specific dst.
		dst := "./test-img/" + file.Filename
		ctx.SaveUploadedFile(file, dst)

		//TODO: Not Save to disk
		err := fs.UploadFile(dst, path)
		if err != nil {
			ctx.String(http.StatusInternalServerError, "TODO") //TODO
			return
		}

		// webFsCollection.CreateMiniatures("./test-img/", file.Filename)

		// webfs.CreateFile(&img, "/home/user/")

		ctx.Status(http.StatusCreated)
	})

	route.GET("writeFile", func(ctx *gin.Context) {
		parentPath := ctx.Query("parentPath")
		if parentPath == "" {
			ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
			return
		}
		file := WebFSFile{
			MongoId: primitive.NewObjectID(),
			Name:    "pp",
			Type:    "test",
			Data:    nil,
		}
		err := fs.CreateFile(&file, parentPath)
		if err != nil {
			ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
			return
		}

		ctx.JSON(http.StatusOK, "OK")
	})
	route.GET("createDir", func(ctx *gin.Context) {
		path := ctx.Query("path")
		if path == "" {
			ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
			return
		}

		err := fs.CreateDirectory(path)
		if err != nil {
			ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
			return
		}

		ctx.JSON(http.StatusOK, "OK")
	})

	route.GET("list", func(ctx *gin.Context) {
		path := ctx.Query("path")
		if path == "" {
			ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
			return
		}

		files, err := fs.List(path)
		if err != nil {
			ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
			return
		}

		ctx.JSON(http.StatusOK, &files)
	})

	route.GET("read", func(ctx *gin.Context) {
		path := ctx.Query("path")
		if path == "" {
			ctx.JSON(http.StatusBadRequest, "TODO") //TODO json error struct
			return
		}

		file, err := fs.Read(path)
		if err != nil {
			ctx.JSON(http.StatusInternalServerError, "TODO") //TODO json error struct
			return
		}

		ctx.JSON(http.StatusOK, &file)
	})

	route.GET("validate", func(ctx *gin.Context) {
		err := fs.Validate()
		if err != nil {
			ctx.Status(http.StatusInternalServerError)
			return
		}

		ctx.Status(http.StatusOK)
	})

	route.GET("delete", func(ctx *gin.Context) {
		path := ctx.Query("path")
		if path == "" {
			ctx.Status(http.StatusBadRequest) //TODO
			return
		}
		err := fs.Delete(path)
		if err != nil {
			ctx.Status(http.StatusInternalServerError)
			return
		}

		ctx.Status(http.StatusOK)
	})
}

func (fs *WebFileSystem) Validate() error {
	filter := primitive.D{
		{
			Key:   "type",
			Value: "directory",
		},
	}
	cur, err := fs.webfsCollection.Find(context.Background(), filter)
	if err != nil {
		return err
	}
	defer cur.Close(context.Background())

	directories := []*WebFSFile{}

	for cur.Next(context.Background()) {
		dir := &WebFSFile{}

		err = cur.Decode(dir)
		if err != nil {
			println(err.Error())
			return err
		}
		directories = append(directories, dir)
	}

	for _, d := range directories {
		fs.validateDir(d)
	}
	return nil
}

func (fs *WebFileSystem) validateDir(dir *WebFSFile) error {
	kek := dir.Data.(primitive.D).Map()["children"].(primitive.A)
	_ = kek

	children := []primitive.ObjectID{}
	counter := 0
	for _, v := range kek {
		_, err := fs.ReadByObjectID(v.(primitive.ObjectID))
		if err != nil {
			counter++
		} else {
			children = append(children, v.(primitive.ObjectID))
		}
	}
	if counter > 0 {
		println(dir.Name + " broken iDs: " + strconv.Itoa(counter))
		_, err := fs.webfsCollection.UpdateByID(context.Background(), dir.MongoId, bson.M{"$set": bson.M{"data.children": children}})
		if err != nil {
			println(err.Error())
			return err
		}
	}

	return nil
}

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:"-"`
	Icon    string             `bson:"-"    json:"icon"`
}

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) GetFileName() string {
	return e.Name
}

// type WebFSFile2 interface {
// 	GetName() string
// 	GetType() string
// 	GetData() interface{}
// }