package tests

import (
	"context"
	"database/sql"
	"errors"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/ihexxa/quickshare/src/db"
	"github.com/ihexxa/quickshare/src/db/rdb/sqlite"
)

func TestFileStore(t *testing.T) {
	testSharingMethods := func(t *testing.T, store db.IDBQuickshare) {
		dirPaths := []string{"admin/path1", "admin/path1/path2"}
		var err error

		ctx := context.TODO()
		adminId := uint64(0)

		// add some of paths...
		err = store.AddFileInfo(ctx, adminId, "admin/path1", &db.FileInfo{
			// Shared:  false, // deprecated
			IsDir:   false,
			Size:    int64(0),
			ShareID: "",
			Sha1:    "",
		})
		if err != nil {
			t.Fatal(err)
		}

		// add sharings
		for _, dirPath := range dirPaths {
			err = store.AddSharing(ctx, adminId, dirPath)
			if err != nil {
				t.Fatal(err)
			}
		}

		// list sharings
		dirToID, err := store.ListUserSharings(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if len(dirToID) != len(dirPaths) {
			t.Fatal("share size not match")
		}

		for _, sharingDir := range dirPaths {
			if _, ok := dirToID[sharingDir]; !ok {
				t.Fatalf("sharing(%s) not found", sharingDir)
			}
			mustTrue, err := store.IsSharing(ctx, adminId, sharingDir)
			if err != nil {
				t.Fatal(err)
			} else if !mustTrue {
				t.Fatalf("get sharing(%t) should exist", mustTrue)
			}

			info, err := store.GetFileInfo(ctx, sharingDir)
			if err != nil {
				t.Fatal(err)
			} else if len(info.ShareID) != 7 {
				t.Fatalf("incorrect ShareID %s", info.ShareID)
			}

			gotSharingDir, err := store.GetSharingDir(ctx, info.ShareID)
			if err != nil {
				t.Fatal(err)
			} else if sharingDir != gotSharingDir {
				t.Fatalf("sharing dir not consist: (%s) (%s)", sharingDir, gotSharingDir)
			}
		}

		// del sharings
		for _, dirPath := range dirPaths {
			err = store.DelSharing(ctx, adminId, dirPath)
			if err != nil {
				t.Fatal(err)
			}
		}

		// list sharings
		dirToIDAfterDel, err := store.ListUserSharings(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if len(dirToIDAfterDel) != 0 {
			t.Fatalf("share size not match (%+v)", dirToIDAfterDel)
		}

		for _, dirPath := range dirPaths {
			if _, ok := dirToIDAfterDel[dirPath]; ok {
				t.Fatalf("sharing(%s) should not exist", dirPath)
			}
			shared, err := store.IsSharing(ctx, adminId, dirPath)
			if err != nil {
				t.Fatal(err)
			} else if shared {
				t.Fatalf("get sharing(%t) should not shared but exist", shared)
			}

			info, err := store.GetFileInfo(ctx, dirPath)
			if err != nil {
				t.Fatal(err)
			} else if len(info.ShareID) != 0 {
				t.Fatalf("ShareID should be empty %s", info.ShareID)
			}

			// shareIDs are removed, use original dirToID to get shareID
			originalShareID, ok := dirToID[dirPath]
			if !ok {
				t.Fatalf("dir (%s) should exist in originalShareID", dirPath)
			}

			_, err = store.GetSharingDir(ctx, originalShareID)
			if !errors.Is(err, db.ErrSharingNotFound) {
				t.Fatal("should return ErrSharingNotFound")
			}
		}
	}

	testFileInfoMethods := func(t *testing.T, store db.IDBQuickshare) {
		pathInfos := map[string]*db.FileInfo{
			"admin/origin/item1": &db.FileInfo{
				// Shared:  false, // deprecated
				IsDir:   false,
				Size:    int64(7),
				ShareID: "",
				Sha1:    "item1_sha",
			},
			"admin/origin/item2": &db.FileInfo{
				// Shared:  false, // deprecated
				IsDir:   false,
				Size:    int64(3),
				ShareID: "",
				Sha1:    "item2_sha",
			},
			"admin/origin/dir": &db.FileInfo{
				// Shared:  true, // deprecated
				IsDir:   true,
				Size:    int64(0),
				ShareID: "mockedShareID",
				Sha1:    "",
			},
		}
		var err error

		adminId := uint64(0)
		ctx := context.TODO()
		// add infos
		usedSpace := int64(0)
		itemPaths := []string{}
		for itemPath, info := range pathInfos {
			err = store.AddFileInfo(ctx, adminId, itemPath, info)
			if err != nil {
				t.Fatal(err)
			}
			usedSpace += info.Size
			itemPaths = append(itemPaths, itemPath)
		}

		// get infos
		for itemPath, expected := range pathInfos {
			info, err := store.GetFileInfo(ctx, itemPath)
			if err != nil {
				t.Fatal(err)
			}
			if info.ShareID != expected.ShareID ||
				info.IsDir != expected.IsDir ||
				info.Sha1 != expected.Sha1 ||
				info.Size != expected.Size {
				t.Fatalf("info not equaled (%v) (%v)", expected, info)
			}
		}

		// list infos
		pathToInfo, err := store.ListFileInfos(ctx, itemPaths)
		if err != nil {
			t.Fatal(err)
		} else if len(pathToInfo) != len(pathInfos) {
			t.Fatalf("list result size not match (%v) (%d)", pathToInfo, len(pathInfos))
		}
		for pathname, info := range pathInfos {
			gotInfo, ok := pathToInfo[pathname]
			if !ok {
				t.Fatalf("path not found (%s)", pathname)
			}
			if info.ShareID != gotInfo.ShareID ||
				info.IsDir != gotInfo.IsDir ||
				info.Sha1 != gotInfo.Sha1 ||
				info.Size != gotInfo.Size {
				t.Fatalf("info not equaled (%v) (%v)", gotInfo, info)
			}
		}

		// set sha1
		testSha1 := "sha1"
		for itemPath := range pathInfos {
			err := store.SetSha1(ctx, itemPath, testSha1)
			if err != nil {
				t.Fatal(err)
			}
			info, err := store.GetFileInfo(ctx, itemPath)
			if err != nil {
				t.Fatal(err)
			}
			if info.Sha1 != testSha1 {
				t.Fatalf("sha not equaled (%v) (%v)", info.Sha1, testSha1)
			}
		}

		// move paths
		newPaths := []string{}
		for itemPath, info := range pathInfos {
			newItemPath := strings.ReplaceAll(itemPath, "origin", "new")
			err = store.MoveFileInfos(ctx, adminId, itemPath, newItemPath, info.IsDir)
			if err != nil {
				t.Fatal(err)
			}
			newPaths = append(newPaths, newItemPath)
		}

		// list infos
		pathToInfo, err = store.ListFileInfos(ctx, newPaths)
		if err != nil {
			t.Fatal(err)
		} else if len(pathToInfo) != len(pathInfos) {
			t.Fatalf("list result size not match (%v) (%d)", pathToInfo, len(pathInfos))
		}

		// check used space
		adminInfo, err := store.GetUser(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if adminInfo.UsedSpace != usedSpace {
			t.Fatalf("used space not match (%d) (%d)", adminInfo.UsedSpace, usedSpace)
		}

		// del info
		for _, itemPath := range newPaths {
			err = store.DelFileInfo(ctx, adminId, itemPath)
			if err != nil {
				t.Fatal(err)
			}
		}

		// check used space
		adminInfo, err = store.GetUser(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if adminInfo.UsedSpace != int64(0) {
			t.Fatalf("used space not match (%d) (%d)", adminInfo.UsedSpace, int64(0))
		}

		// list infos
		pathToInfo, err = store.ListFileInfos(ctx, itemPaths)
		if err != nil {
			t.Fatal(err)
		} else if len(pathToInfo) != 0 {
			t.Fatalf("list result should be empty (%v)", pathToInfo)
		}

		for itemPath := range pathInfos {
			_, err := store.GetFileInfo(ctx, itemPath)
			if !errors.Is(err, db.ErrFileInfoNotFound) {
				t.Fatal(err)
			}
		}
	}

	testUploadingMethods := func(t *testing.T, store db.IDBQuickshare) {
		pathInfos := map[string]*db.FileInfo{
			"admin/origin/item1": &db.FileInfo{
				// Shared:  false, // deprecated
				IsDir:   false,
				Size:    int64(7),
				ShareID: "",
				Sha1:    "",
			},
			"admin/origin/item2": &db.FileInfo{
				// Shared:  false, // deprecated
				IsDir:   false,
				Size:    int64(3),
				ShareID: "",
				Sha1:    "",
			},
			"admin/origin/to_delete/item3": &db.FileInfo{
				// Shared:  false, // deprecated
				IsDir:   false,
				Size:    int64(11),
				ShareID: "",
				Sha1:    "",
			},
		}
		var err error

		adminId := uint64(0)
		ctx := context.TODO()

		// add infos
		usedSpace := int64(0)
		usedSpaceAfterDeleting := int64(0)
		itemPaths := []string{}
		pathToTmpPath := map[string]string{}
		for itemPath, info := range pathInfos {
			tmpPath := strings.ReplaceAll(itemPath, "origin", "uploads")
			pathToTmpPath[itemPath] = tmpPath
			err = store.AddUploadInfos(ctx, adminId, tmpPath, itemPath, info)
			if err != nil {
				t.Fatal(err)
			}
			usedSpace += info.Size
			if !strings.Contains(itemPath, "delete") {
				usedSpaceAfterDeleting += info.Size
			}
			itemPaths = append(itemPaths, itemPath)
		}

		// get infos
		for itemPath, info := range pathInfos {
			gotPath, size, uploaded, err := store.GetUploadInfo(ctx, adminId, itemPath)
			if err != nil {
				t.Fatal(err)
			}
			if size != info.Size ||
				uploaded != int64(0) ||
				gotPath != itemPath {
				t.Fatalf("info not equaled (%v)", info)
			}
		}

		// list infos
		uploadInfos, err := store.ListUploadInfos(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if len(uploadInfos) != len(pathInfos) {
			t.Fatalf("list result size not match (%v) (%d)", uploadInfos, len(pathInfos))
		}
		for _, uploadInfo := range uploadInfos {
			expected, ok := pathInfos[uploadInfo.RealFilePath]
			if !ok {
				t.Fatalf("path not found (%s)", uploadInfo.RealFilePath)
			}
			if uploadInfo.Uploaded != int64(0) ||
				expected.Size != uploadInfo.Size {
				t.Fatalf("info not equaled (%d) (%d)", uploadInfo.Uploaded, uploadInfo.Size)
			}
		}

		// check used space
		adminInfo, err := store.GetUser(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if adminInfo.UsedSpace != usedSpace {
			t.Fatalf("used space not match (%d) (%d)", adminInfo.UsedSpace, usedSpace)
		}

		// set uploading
		for itemPath, info := range pathInfos {
			err := store.SetUploadInfo(ctx, adminId, itemPath, int64(info.Size/2))
			if err != nil {
				t.Fatal(err)
			}
			gotPath, size, uploaded, err := store.GetUploadInfo(ctx, adminId, itemPath)
			if err != nil {
				t.Fatal(err)
			}
			if gotPath != itemPath || size != info.Size || uploaded != info.Size/2 {
				t.Fatal("uploaded info not match")
			}
		}

		// check used space
		adminInfo, err = store.GetUser(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if adminInfo.UsedSpace != usedSpace {
			t.Fatalf("used space not match (%d) (%d)", adminInfo.UsedSpace, usedSpace)
		}

		// del info
		for itemPath := range pathInfos {
			err = store.DelUploadingInfos(ctx, adminId, itemPath)
			if err != nil {
				t.Fatal(err)
			}
		}

		// check used space
		adminInfo, err = store.GetUser(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if adminInfo.UsedSpace != int64(0) {
			t.Fatalf("used space not match (%d) (%d)", adminInfo.UsedSpace, int64(0))
		}

		// list infos
		uploadInfos, err = store.ListUploadInfos(ctx, adminId)
		if err != nil {
			t.Fatal(err)
		} else if len(uploadInfos) != 0 {
			t.Fatalf("list result size not match (%v) (%d)", uploadInfos, 0)
		}

		for itemPath := range pathInfos {
			_, _, _, err := store.GetUploadInfo(ctx, adminId, itemPath)
			if !errors.Is(err, sql.ErrNoRows) {
				t.Fatal(err)
			}
		}
	}

	t.Run("testing file info store - sqlite", func(t *testing.T) {
		rootPath, err := ioutil.TempDir("./", "qs_sqlite_test_")
		if err != nil {
			t.Fatal(err)
		}
		defer os.RemoveAll(rootPath)

		dbPath := filepath.Join(rootPath, "files.sqlite")
		sqliteDB, err := sqlite.NewSQLite(dbPath)
		if err != nil {
			t.Fatal(err)
		}
		defer sqliteDB.Close()

		store, err := sqlite.NewSQLiteStore(sqliteDB)
		if err != nil {
			t.Fatal("fail to new sqlite store", err)
		}
		err = store.Init(context.TODO(), "admin", "1234", testSiteConfig)
		if err != nil {
			t.Fatal("fail to init", err)
		}

		testSharingMethods(t, store)
		testFileInfoMethods(t, store)
		testUploadingMethods(t, store)
	})
}