package file

import (
	"encoding/json"
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"strings"

	"git.andreafazzi.eu/andrea/probo/client"
	"git.andreafazzi.eu/andrea/probo/models"
)

func (s *FileProboCollectorStore) GetCollectionsDir() string {
	return s.collectionsDir
}

func (s *FileProboCollectorStore) GetCollectionPath(collection *models.Collection) (string, error) {
	s.lock.RLock()
	defer s.lock.RUnlock()

	path, ok := s.collectionsPaths[collection.ID]
	if !ok {
		return "", errors.New(fmt.Sprintf("Path not found for collection ID %v", collection.ID))
	}
	return path, nil
}

func (s *FileProboCollectorStore) SetCollectionPath(collection *models.Collection, path string) string {
	s.lock.Lock()
	defer s.lock.Unlock()

	s.collectionsPaths[collection.ID] = path

	return path
}

func (s *FileProboCollectorStore) ReadAllCollections() ([]*models.Collection, error) {
	return s.memoryStore.ReadAllCollections()
}

func (s *FileProboCollectorStore) CreateCollection(r *client.CreateUpdateCollectionRequest) (*models.Collection, error) {
	collection, err := s.memoryStore.CreateCollection(r)
	if err != nil {
		return nil, err
	}

	err = s.createOrUpdateCollectionFile(collection)
	if err != nil {
		return nil, err
	}

	return s.memoryStore.ReadCollectionByID(collection.ID)
}

func (s *FileProboCollectorStore) UpdateCollection(r *client.CreateUpdateCollectionRequest, id string) (*models.Collection, error) {
	collection, _, err := s.memoryStore.UpdateCollection(r, id)
	if err != nil {
		return nil, err
	}

	err = s.createOrUpdateCollectionFile(collection)
	if err != nil {
		return nil, err
	}

	return s.memoryStore.ReadCollectionByID(collection.ID)
}

func (s *FileProboCollectorStore) DeleteCollection(r *client.DeleteCollectionRequest) (*models.Collection, error) {
	collection, err := s.memoryStore.DeleteCollection(&client.DeleteCollectionRequest{ID: r.ID})
	if err != nil {
		return nil, err
	}

	path, err := s.GetCollectionPath(collection)
	if err != nil {
		return nil, err
	}

	err = os.Remove(path)
	if err != nil {
		return nil, err
	}

	return collection, nil
}

func (s *FileProboCollectorStore) reindexCollections() error {
	files, err := os.ReadDir(s.collectionsDir)
	if err != nil {
		return err
	}

	jsonFiles := make([]fs.DirEntry, 0)

	for _, file := range files {
		filename := file.Name()
		if !file.IsDir() && strings.HasSuffix(filename, ".json") {
			jsonFiles = append(jsonFiles, file)
		}
	}

	for _, file := range jsonFiles {
		filename := file.Name()
		fullPath := filepath.Join(s.collectionsDir, filename)

		content, err := os.ReadFile(fullPath)
		if err != nil {
			return err
		}

		var clientCollection *client.Collection

		err = json.Unmarshal(content, &clientCollection)
		if err != nil {
			return err
		}

		collection, err := s.memoryStore.CreateCollection(&client.CreateUpdateCollectionRequest{
			Collection: clientCollection,
		})
		if err != nil {
			return err
		}

		s.SetCollectionPath(collection, fullPath)
	}

	return nil
}

func (s *FileProboCollectorStore) createOrUpdateCollectionFile(collection *models.Collection) error {
	json, err := json.Marshal(collection)
	if err != nil {
		return err
	}

	fn, _ := s.GetCollectionPath(collection)
	if fn == "" {
		fn = filepath.Join(s.collectionsDir, fmt.Sprintf("collection_%v.%s", collection.ID, "json"))
	}

	file, err := os.Create(fn)
	if err != nil {
		return err
	}
	defer file.Close()

	_, err = file.Write([]byte(json))
	if err != nil {
		return err
	}

	s.SetCollectionPath(collection, fn)

	return nil
}