package storage

import (
	"archive/tar"
	"compress/gzip"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path"
	"strings"

	"gosimplenpm/serviceidos"
	"path/filepath"
)

func GetRegistryPath() (string, error) {
	registryPath, err := filepath.Abs("./examples")
	if err != nil {
		fmt.Printf("File repo not found: +%v\n", err)
		return "", err
	}
	return registryPath, err
}

func GetIndexJsonFromStore(packageName string) (string, bool, error) {
	fileToServe := ""
	found := false
	searchDir, err := GetRegistryPath()
	if err != nil {
		return searchDir, found, err
	}

	err = filepath.WalkDir(searchDir, func(fp string, info fs.DirEntry, e error) error {
		if strings.Contains(fp, path.Join(packageName, "index.json")) {
			fileToServe = fp
			found = true
		}
		return e
	})

	if err != nil {
		fmt.Printf("List files error: +%v\n", err)
		return fileToServe, found, err
	}

	if fileToServe == "" && !found {
		fileToServe = path.Join(searchDir, packageName, "index.json")
	}

	return fileToServe, found, nil
}

func GetTarFromStore(packageName string, tarFileName string) (string, error) {
	fileToServe := ""
	searchDir, err := GetRegistryPath()
	if err != nil {
		return searchDir, err
	}

	err = filepath.WalkDir(searchDir, func(fp string, info fs.DirEntry, e error) error {
		if strings.Contains(fp, path.Join(packageName, tarFileName)) {
			fileToServe = fp
		}
		return e
	})

	if err != nil {
		fmt.Printf("List files error: +%v\n", err)
		return fileToServe, err
	}

	if fileToServe == "" {
		return fileToServe, fmt.Errorf("file %s is not found for package %s", tarFileName, packageName)
	}

	file, err := os.Open(fileToServe)
	if err != nil {
		fmt.Printf("Open error: %s\n", fileToServe)
		return "", err
	}

	archive, err := gzip.NewReader(file)
	if err != nil {
		fmt.Printf("Archive Open error: %s\n", fileToServe)
		return "", err
	}

	tr := tar.NewReader(archive)
	bs, err := io.ReadAll(tr)
	if err != nil {
		fmt.Printf("Archive Read error: %s\n", fileToServe)
		return "", err
	}
	return base64.StdEncoding.EncodeToString(bs), err
}

func ReadIndexJson(fPath string, res *serviceidos.IndexJson) error {
	jsonFile, err := os.Open(fPath)
	if err != nil {
		fmt.Printf("File Not found: %s\n", fPath)
		return err
	}

	defer jsonFile.Close()

	err = json.NewDecoder(jsonFile).Decode(res)
	if err != nil {
		fmt.Printf("Unmarshalerror: %+v\n", err)
		return err
	}

	return nil
}

func WriteIndexJson(fPath string, res *serviceidos.IndexJson) error {
	// Need to create the directory first
	parent := path.Dir(fPath)
	err := os.MkdirAll(parent, os.ModePerm)
	if err != nil {
		fmt.Printf("Folder (%s) creation failed.\n", fPath)
		return err
	}

	// Create the file
	jsonFile, err := os.Create(fPath)

	if err != nil {
		fmt.Printf("Creation error for path(%s): %+v\n ", fPath, err)
		return err
	}

	defer jsonFile.Close()

	err = json.NewEncoder(jsonFile).Encode(res)
	if err != nil {
		fmt.Printf("Marshalerror: %+v\n", err)
		return err
	}

	return nil
}

func WritePackageToStore(fPath string, data string) error {
	dec, err := base64.StdEncoding.DecodeString(data)
	if err != nil {
		fmt.Printf("Base64 Decode error: %+v\n", err)
		return err
	}

	dataFile, err := os.Create(fPath)
	if err != nil {
		fmt.Printf("Creation error: %s\n", fPath)
		return err
	}

	defer dataFile.Close()

	_, err = dataFile.Write(dec)
	if err != nil {
		fmt.Printf("Write error: %s\n", fPath)
		return err
	}

	err = dataFile.Sync()
	if err != nil {
		fmt.Printf("Sync error: %s\n", fPath)
		return err
	}

	return nil
}