package synchronizator

import (
	"context"
	"fmt"
	"slices"
	"strings"
)

type default_collection struct {
	platform_name string
}

func (collection *default_collection) GetClass() string {
	platform_name := strings.ToUpper(collection.platform_name)
	return platform_name + "_DEFAULT"
}

func (collection *default_collection) GetMetadata() []byte {
	return nil
}

func (collection *default_collection) FromNode(_class string, name string, metadata []byte) error {
	if _class != "DEFAULT" {
		return fmt.Errorf("invalid class %s", _class)
	}
	return nil
}

// Utility struct to represent a collection of nodes, it's a [Node] itself so all
// the node's functionality is available.
type Collection struct {
	Node               // Underlaying node info
	childs     []*Node // Child nodes
	is_default bool
}

// NewCollectionObject creates a new Collection instance without persisting it to the database.
// This is useful when you want to prepare a Collection for later storage.
func NewCollection(name string, metadata []byte) *Collection {
	return &Collection{
		Node: Node{
			name:     name,
			_class:   "COLLECTION",
			metadata: metadata,
			Id:       -1, // Use -1 to indicate not persisted
		},
		childs:     make([]*Node, 0),
		is_default: false,
	}
}

// Internal RelationshipClass to handle the collection to node relationship
type collection_has_node struct {
	Relationship
}

func (col_has_node *collection_has_node) GetClass() string {
	return "COLLECTION_HAS"
}

func (col_has_node *collection_has_node) GetMetadata() []byte {
	return nil
}

func (col_has_node *collection_has_node) FromRelationship(_class string, metadata []byte) error {
	if _class != "COLLECTION_HAS" {
		return fmt.Errorf("invalid class %s", _class)
	}
	return nil
}

// Adds a new child to this collection. Use the underlaying node's AddRelation
// method.
func (collection *Collection) AddChild(node *Node) error {
	_, err := collection.StoreRelation(&collection_has_node{}, node.Id)
	if err != nil {
		return err
	}

	collection.childs = append(collection.childs, node)

	return nil
}

func (collection *Collection) IsDefault() bool {
	return collection.is_default
}

// Is a type alias for FetchResponse containing a slice of Collection pointers.
type FetchNodesResponse = FetchResponse[[]*Node]

// Fetches collections using the provided fetcher and pagination settings.
// It updates the platform's collections and creates relationships between the platform and the collections.
//
// Parameters:
// - ctx: The context to control cancellation.
// - fetcher: The fetcher function to execute the work.
// - start_pagination: The initial pagination settings.
// - pool_config: The configuration for the worker pool.
//
// Returns:
// - error: The error if any occurred.
func (collection *Collection) FetchNodes(
	ctx context.Context,
	fetcher Work[Pagination, FetchNodesResponse],
	startPagination Pagination,
	poolConfig *WorkConfig,
) error {
	values, err := fetchWithPagination(ctx, poolConfig, fetcher, startPagination)
	if err != nil {
		return err
	}

	collection.childs = slices.Concat(collection.childs, values)

	fmt.Printf("Nodes: %v\n", len(collection.childs))

	err = BulkCreateNode(collection._conn, values)
	if err != nil {
		return err
	}

	relationships := make([]*Relationship, 0, len(values))

	for _, item := range values {
		relation := &Relationship{
			_class: "COLLECTION_HAS_NODE",
			From:   collection.Id,
			To:     item.Id,
		}

		err := collection.AddRelationship(relation)
		if err != nil {
			return err
		}
		relationships = append(relationships, relation)
	}

	err = BulkCreateRelationships(collection._conn, relationships)
	if err != nil {
		return err
	}

	return nil
}