package internal

import (
	"context"
	"fmt"

	"git.dragse.it/anthrove/otter-space-sdk/internal/utils"
	"git.dragse.it/anthrove/otter-space-sdk/pkg/models"
	"github.com/neo4j/neo4j-go-driver/v5/neo4j"
	log "github.com/sirupsen/logrus"
)

func CreateUserNodeWithSourceRelation(ctx context.Context, driver neo4j.DriverWithContext, anthroveUserID models.AnthroveUserID, sourceDomain string, userID string, username string) error {
	query := `
		MATCH (userNode:User {user_id: $anthrove_user_id})
		MATCH (sourceNode:Source {domain: $source_domain})
		MERGE (userNode)-[r:HAS_ACCOUNT_AT {username: $source_user_name, user_id: $source_user_id}]->(sourceNode)
	`
	params := map[string]any{
		"anthrove_user_id": anthroveUserID,
		"source_user_id":   userID,
		"source_user_name": username,
		"source_domain":    sourceDomain,
	}

	_, err := neo4j.ExecuteQuery(ctx, driver, query, params, neo4j.EagerResultTransformer)
	if err != nil {
		return err
	}

	var anthroveUserRelationship []models.AnthroveUserRelationship

	anthroveUserRelationship = append(anthroveUserRelationship, models.AnthroveUserRelationship{
		UserID:             userID,
		Username:           username,
		ScrapeTimeInterval: "",
		Source: models.AnthroveSource{
			DisplayName: "",
			Domain:      sourceDomain,
			Icon:        "",
		},
	})

	log.WithFields(log.Fields{
		"anthrove_user_id": anthroveUserID,
		"source_user_id":   userID,
		"source_user_name": username,
		"source_domain":    sourceDomain,
	}).Trace("graph: crated user with relationship")

	return nil
}

func GetUserFavoritesCount(ctx context.Context, driver neo4j.DriverWithContext, anthroveUserID models.AnthroveUserID) (int64, error) {
	var userFavoriteCount int64

	query := `
		MATCH (userNode:User {user_id: $anthrove_user_id})
		MATCH (userNode)-[:FAV]->(favPost:AnthrovePost)
		MATCH (sourceNode)-[:REFERENCE]->(favPost)
		RETURN  count( DISTINCT favPost) AS FavoritePostsCount
	`

	params := map[string]any{
		"anthrove_user_id": anthroveUserID,
	}

	result, err := neo4j.ExecuteQuery(ctx, driver, query, params, neo4j.EagerResultTransformer)
	if err != nil {
		return 0, err
	}

	if len(result.Records) == 0 {
		// no matches -> user does not exist, return count 0
		return userFavoriteCount, err
	}

	record := result.Records[0]

	userFavoriteCount, _, err = neo4j.GetRecordValue[int64](record, "FavoritePostsCount")
	if err != nil {
		return userFavoriteCount, err
	}

	log.WithFields(log.Fields{
		"anthrove_user_id":        anthroveUserID,
		"anthrove_user_fav_count": userFavoriteCount,
	}).Trace("graph: got user favorite count")

	return userFavoriteCount, nil
}

func GetUserSourceLink(ctx context.Context, driver neo4j.DriverWithContext, anthroveUserID models.AnthroveUserID) (map[string]models.AnthroveUserRelationship, error) {

	userSource := make(map[string]models.AnthroveUserRelationship)

	query := `
		MATCH (user:User{user_id: $anthrove_user_id})-[r:HAS_ACCOUNT_AT]->(s:Source)
		RETURN toString(r.user_id) AS sourceUserID, toString(r.username) AS sourceUsername, s as source;
	`
	params := map[string]any{
		"anthrove_user_id": anthroveUserID,
	}

	result, err := neo4j.ExecuteQuery(ctx, driver, query, params, neo4j.EagerResultTransformer)
	if err != nil {
		return nil, err
	}

	if len(result.Records) == 0 {
		return nil, fmt.Errorf("user has no relations")
	}

	for i := range result.Records {
		record := result.Records[i]
		source, _, err := neo4j.GetRecordValue[neo4j.Node](record, "source")
		if err != nil {
			return nil, err
		}
		sourceUserID, _, err := neo4j.GetRecordValue[string](record, "sourceUserID")
		if err != nil {
			return nil, err
		}
		sourceUsername, _, err := neo4j.GetRecordValue[string](record, "sourceUsername")
		if err != nil {
			return nil, err
		}

		displayName := source.Props["display_name"].(string)
		domain := source.Props["domain"].(string)
		icon := source.Props["icon"].(string)

		anthroveSourceUser := models.AnthroveUserRelationship{
			UserID:   sourceUserID,
			Username: sourceUsername,
			Source: models.AnthroveSource{
				DisplayName: displayName,
				Domain:      domain,
				Icon:        icon,
			},
		}
		userSource[displayName] = anthroveSourceUser
	}

	log.WithFields(log.Fields{
		"anthrove_user_id": anthroveUserID,
		"anthrove_data":    userSource,
	}).Trace("graph: got user favorite count")

	return userSource, nil
}

func GetSpecifiedUserSourceLink(ctx context.Context, driver neo4j.DriverWithContext, anthroveUserID models.AnthroveUserID, sourceDisplayName string) (map[string]models.AnthroveUserRelationship, error) {

	userSource := make(map[string]models.AnthroveUserRelationship)

	query := `
		MATCH (user:User{user_id: $anthrove_user_id})-[r:HAS_ACCOUNT_AT]->(s:Source{display_name: $source_display_name})
		RETURN toString(r.user_id) AS sourceUserID, toString(r.username) AS sourceUsername, s as source;
	`
	params := map[string]any{
		"anthrove_user_id":    anthroveUserID,
		"source_display_name": sourceDisplayName,
	}

	result, err := neo4j.ExecuteQuery(ctx, driver, query, params, neo4j.EagerResultTransformer)
	if err != nil {
		return nil, err
	}

	if len(result.Records) == 0 {
		return nil, fmt.Errorf("user has no relations with the source %s", sourceDisplayName)
	}

	for i := range result.Records {
		record := result.Records[i]
		source, _, err := neo4j.GetRecordValue[neo4j.Node](record, "source")
		if err != nil {
			return nil, err
		}
		sourceUserID, _, err := neo4j.GetRecordValue[string](record, "sourceUserID")
		if err != nil {
			return nil, err
		}
		sourceUsername, _, err := neo4j.GetRecordValue[string](record, "sourceUsername")
		if err != nil {
			return nil, err
		}

		displayName := source.Props["display_name"].(string)
		domain := source.Props["domain"].(string)
		icon := source.Props["icon"].(string)

		anthroveSourceUser := models.AnthroveUserRelationship{
			UserID:   sourceUserID,
			Username: sourceUsername,
			Source: models.AnthroveSource{
				DisplayName: displayName,
				Domain:      domain,
				Icon:        icon,
			},
		}
		userSource[displayName] = anthroveSourceUser
	}

	log.WithFields(log.Fields{
		"anthrove_user_id": anthroveUserID,
		"anthrove_data":    userSource,
	}).Trace("graph: got user favorite count")

	return userSource, nil
}

func GetAnthroveUser(ctx context.Context, driver neo4j.DriverWithContext, anthroveUserID models.AnthroveUserID) (*models.AnthroveUser, error) {
	var err error
	var anthroveUser models.AnthroveUser
	var userSources models.AnthroveSource
	userRelationships := make([]models.AnthroveUserRelationship, 0)

	query := `
		MATCH (user:User{user_id: $anthrove_user_id})-[relation:HAS_ACCOUNT_AT]->(source:Source)
		RETURN user as User, relation as Relation, source as Source;
	`
	params := map[string]any{
		"anthrove_user_id": anthroveUserID,
	}

	result, err := neo4j.ExecuteQuery(ctx, driver, query, params, neo4j.EagerResultTransformer)
	if err != nil {
		return nil, err
	}

	if len(result.Records) == 0 {
		return nil, fmt.Errorf("user has no relations")
	}

	for i := range result.Records {
		record := result.Records[i]

		user, _, err := neo4j.GetRecordValue[neo4j.Node](record, "User")
		if err != nil {
			return nil, err
		}
		relation, _, err := neo4j.GetRecordValue[neo4j.Relationship](record, "Relation")
		if err != nil {
			return nil, err
		}
		source, _, err := neo4j.GetRecordValue[neo4j.Node](record, "Source")
		if err != nil {
			return nil, err
		}

		userRelationships = append(userRelationships, models.AnthroveUserRelationship{
			UserID:             fmt.Sprintf("%v", utils.GetOrDefault(relation.Props, "user_id", "")),
			Username:           utils.GetOrDefault(relation.Props, "username", "").(string),
			ScrapeTimeInterval: utils.GetOrDefault(relation.Props, "scrape_time_interval", "").(string),
		})

		userSources = models.AnthroveSource{
			DisplayName: utils.GetOrDefault(source.Props, "display_name", "").(string),
			Domain:      utils.GetOrDefault(source.Props, "domain", "").(string),
			Icon:        utils.GetOrDefault(source.Props, "icon", "").(string),
		}

		anthroveUser.UserID = models.AnthroveUserID(utils.GetOrDefault(user.Props, "user_id", "").(string))
		anthroveUser.Relationship = userRelationships

		for j := range userRelationships {
			anthroveUser.Relationship[j].Source = userSources
		}

	}

	log.WithFields(log.Fields{
		"anthrove_user_id": anthroveUserID,
	}).Trace("graph: got anthrove user")

	return &anthroveUser, nil

}

func GetAllAnthroveUserIDs(ctx context.Context, driver neo4j.DriverWithContext) ([]models.AnthroveUserID, error) {
	var err error
	var anthroveUsers []models.AnthroveUserID

	query := `
		MATCH (anthroveUser:User)
		RETURN anthroveUser
	`
	result, err := neo4j.ExecuteQuery(ctx, driver, query, nil, neo4j.EagerResultTransformer)
	if err != nil {
		return nil, err
	}

	if len(result.Records) == 0 {
		log.Warnf("No users found, this should not be happening!")
		return []models.AnthroveUserID{}, nil
	}

	for i := range result.Records {
		record := result.Records[i]

		user, _, err := neo4j.GetRecordValue[neo4j.Node](record, "anthroveUser")
		if err != nil {
			return nil, err
		}

		anthroveUsers = append(anthroveUsers, models.AnthroveUserID(fmt.Sprintf(user.Props["user_id"].(string))))
	}

	log.WithFields(log.Fields{
		"anthrove_user_id_count": len(anthroveUsers),
	}).Trace("graph: got al anthrove user IDs")

	return anthroveUsers, nil

}

func GetUserFavoriteNodeWithPagination(ctx context.Context, driver neo4j.DriverWithContext, anthroveUserID models.AnthroveUserID, skip int, limit int) (*models.FavoriteList, error) {
	var err error
	var favoritePosts []models.FavoritePost

	query := `
		CALL { 
		  MATCH (user:User{user_id: $anthrove_user_id})-[r:FAV]->(p:AnthrovePost) 
		  RETURN p.post_id AS post_id 
		  ORDER BY id(p) ASC 
		SKIP $skip
		LIMIT $limit
		} 
		WITH collect(post_id) AS faves 
		MATCH (a:AnthrovePost)<-[r:REFERENCE]-(s:Source) 
		WHERE a.post_id in faves 
		RETURN a AS anthrovePost, r AS postRelation, s AS Source
		ORDER BY id(a) ASC
	`
	params := map[string]any{
		"anthrove_user_id": anthroveUserID,
		"limit":            limit,
		"skip":             skip,
	}

	result, err := neo4j.ExecuteQuery(ctx, driver, query, params, neo4j.EagerResultTransformer)
	if err != nil {
		return nil, err
	}

	if len(result.Records) == 0 {
		return nil, nil
	}

	for i := range result.Records {
		record := result.Records[i]

		anthrovePost, _, err := neo4j.GetRecordValue[neo4j.Node](record, "anthrovePost")
		if err != nil {
			return nil, err
		}

		postRelation, _, err := neo4j.GetRecordValue[neo4j.Relationship](record, "postRelation")
		if err != nil {
			return nil, err
		}

		source, _, err := neo4j.GetRecordValue[neo4j.Node](record, "Source")
		if err != nil {
			return nil, err
		}

		if len(favoritePosts) != 0 && favoritePosts[len(favoritePosts)-1].AnthrovePost.PostID == models.AnthrovePostID(anthrovePost.Props["post_id"].(string)) {
			favoritePosts[len(favoritePosts)-1].Relations = append(favoritePosts[len(favoritePosts)-1].Relations, models.FavoriteRelations{
				SourcesID: source.Props["display_name"].(string),
				Relations: models.AnthrovePostRelationship{
					PostID: postRelation.Props["source_post_id"].(string),
					Url:    postRelation.Props["url"].(string),
				},
			})
		} else {
			favoritePosts = append(favoritePosts, models.FavoritePost{
				AnthrovePost: models.AnthrovePost{
					PostID: models.AnthrovePostID(anthrovePost.Props["post_id"].(string)),
					Rating: models.AnthroveRating(anthrovePost.Props["rating"].(string)),
				},
				Relations: []models.FavoriteRelations{{
					SourcesID: source.Props["display_name"].(string),
					Relations: models.AnthrovePostRelationship{
						PostID: postRelation.Props["source_post_id"].(string),
						Url:    postRelation.Props["url"].(string),
					},
				}},
			})

		}

	}

	log.WithFields(log.Fields{
		"anthrove_user_fav_count": len(favoritePosts),
	}).Trace("graph: got al anthrove user favorites")

	return &models.FavoriteList{Posts: favoritePosts}, nil

}

func GetUserTagNodeWitRelationToFavedPosts(ctx context.Context, driver neo4j.DriverWithContext, anthroveUserID models.AnthroveUserID) ([]models.TagsWithFrequency, error) {
	var userTags []models.TagsWithFrequency

	query := `
		MATCH (u:User {user_id: $anthrove_user_id})-[:FAV]->(:AnthrovePost)-[:HAS]->(t:Tag)
		RETURN t as tag, COUNT(t) AS frequency
		ORDER BY frequency DESC
		`
	params := map[string]any{
		"anthrove_user_id": anthroveUserID,
	}

	result, err := neo4j.ExecuteQuery(ctx, driver, query, params, neo4j.EagerResultTransformer)
	if err != nil {
		return nil, err
	}

	if len(result.Records) == 0 {
		return nil, nil
	}

	for i := range result.Records {
		record := result.Records[i]

		tag, _, err := neo4j.GetRecordValue[neo4j.Node](record, "tag")
		if err != nil {
			return nil, err
		}

		frequency, _, err := neo4j.GetRecordValue[int64](record, "frequency")
		if err != nil {
			return nil, err
		}

		userTags = append(userTags, models.TagsWithFrequency{
			Frequency: frequency,
			Tags: models.AnthroveTag{
				Name: tag.Props["name"].(string),
				Type: tag.Props["type"].(string),
			},
		})

	}

	log.WithFields(log.Fields{
		"tag_amount": len(userTags),
	}).Trace("graph: created tag node")

	return userTags, nil
}