"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var GraphService_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.GraphService = void 0;
const common_1 = require("@nestjs/common");
const prisma_service_1 = require("../prisma/prisma.service");
let GraphService = GraphService_1 = class GraphService {
    prisma;
    logger = new common_1.Logger(GraphService_1.name);
    adjacencyList = new Map();
    constructor(prisma) {
        this.prisma = prisma;
    }
    async onModuleInit() {
        await this.loadEdgesFromDatabase();
    }
    async loadEdgesFromDatabase() {
        try {
            const edges = await this.prisma.graphEdge.findMany();
            for (const edge of edges) {
                const sourceId = edge.source;
                const targetId = edge.target;
                const storedEdge = {
                    source: edge.source,
                    target: edge.target,
                    type: edge.type,
                    weight: edge.weight,
                    metadata: edge.metadata,
                };
                if (!this.adjacencyList.has(sourceId)) {
                    this.adjacencyList.set(sourceId, new Map());
                }
                this.adjacencyList.get(sourceId).set(targetId, storedEdge);
                if (edge.type === "knows" || edge.type === "similar_to" || edge.type === "appeared_on") {
                    const reverseEdge = { ...storedEdge, source: edge.target, target: edge.source };
                    if (!this.adjacencyList.has(edge.target)) {
                        this.adjacencyList.set(edge.target, new Map());
                    }
                    this.adjacencyList.get(edge.target).set(edge.source, reverseEdge);
                }
                if (edge.source.startsWith("guest:") || edge.source.startsWith("podcast:")) {
                    const edges = this.adjacencyList.get(edge.source);
                    if (edge.metadata && typeof edge.metadata === "object") {
                        const meta = edge.metadata;
                        if (meta.nodeData) {
                            edges.nodeData = meta.nodeData;
                        }
                    }
                }
            }
            this.logger.log(`Loaded ${edges.length} graph edges from database`);
        }
        catch (error) {
            this.logger.warn("Failed to load graph edges from database, starting with empty graph", error);
        }
    }
    async ingestProfile(profileId) {
        this.logger.log(`Ingesting profile ${profileId} into graph`);
        const profile = await this.prisma.guestPublicProfile.findUnique({
            where: { id: profileId },
            include: {
                expertiseTags: true,
                bookingHistory: true,
            },
        });
        if (!profile) {
            this.logger.warn(`Profile ${profileId} not found`);
            return;
        }
        this.addNode({
            type: "guest",
            id: `guest:${profileId}`,
            data: {
                name: profile.headline,
                country: profile.country,
                expertise: profile.expertiseTags.map((t) => t.name),
                tier: profile.tier,
            },
        });
        for (const booking of profile.bookingHistory) {
            const podcastNodeId = `podcast:${booking.podcastName}`;
            this.addNode({
                type: "podcast",
                id: podcastNodeId,
                data: { name: booking.podcastName },
            });
            this.addEdge({
                source: `guest:${profileId}`,
                target: podcastNodeId,
                type: "appeared_on",
                weight: 1,
                metadata: {
                    date: booking.appearedAt,
                    topics: booking.topicsDiscussed,
                },
            });
        }
        await this.calculateSimilarityEdges(profileId, profile.expertiseTags);
        this.logger.log(`Profile ${profileId} ingested successfully`);
    }
    addNode(node) {
        if (!this.adjacencyList.has(node.id)) {
            this.adjacencyList.set(node.id, new Map());
        }
        const edges = this.adjacencyList.get(node.id);
        edges.nodeData = node.data;
    }
    addEdge(edge) {
        if (!this.adjacencyList.has(edge.source)) {
            this.adjacencyList.set(edge.source, new Map());
        }
        this.adjacencyList.get(edge.source).set(edge.target, edge);
        if (edge.type === "knows" || edge.type === "similar_to" || edge.type === "appeared_on") {
            const reverseEdge = { ...edge, source: edge.target, target: edge.source };
            if (!this.adjacencyList.has(edge.target)) {
                this.adjacencyList.set(edge.target, new Map());
            }
            this.adjacencyList.get(edge.target).set(edge.source, reverseEdge);
        }
        this.persistEdge(edge).catch(err => this.logger.error(`Failed to persist graph edge`, err));
    }
    async persistEdge(edge) {
        try {
            await this.prisma.graphEdge.upsert({
                where: {
                    source_target_type: {
                        source: edge.source,
                        target: edge.target,
                        type: edge.type,
                    },
                },
                create: {
                    source: edge.source,
                    target: edge.target,
                    type: edge.type,
                    weight: edge.weight,
                    metadata: (edge.metadata || {}),
                },
                update: {
                    weight: edge.weight,
                    metadata: (edge.metadata || {}),
                },
            });
        }
        catch (error) {
            this.logger.error(`Failed to persist edge ${edge.source} -> ${edge.target} (${edge.type})`, error);
        }
    }
    async calculateSimilarityEdges(profileId, expertiseTags) {
        const expertiseNames = expertiseTags.map((t) => t.name);
        if (expertiseNames.length === 0)
            return;
        const similarGuests = await this.prisma.guestPublicProfile.findMany({
            where: {
                id: { not: profileId },
                isPublic: true,
                expertiseTags: {
                    some: {
                        name: { in: expertiseNames },
                    },
                },
            },
            include: {
                expertiseTags: true,
            },
            take: 20,
        });
        for (const other of similarGuests) {
            const otherExpertise = other.expertiseTags.map((t) => t.name);
            const sharedExpertise = expertiseNames.filter((e) => otherExpertise.includes(e));
            if (sharedExpertise.length > 0) {
                const similarityScore = sharedExpertise.length /
                    Math.max(expertiseNames.length, otherExpertise.length);
                this.addEdge({
                    source: `guest:${profileId}`,
                    target: `guest:${other.id}`,
                    type: "similar_to",
                    weight: similarityScore,
                    metadata: {
                        sharedExpertise,
                        score: similarityScore,
                    },
                });
            }
        }
    }
    async getRecommendations(profileId, limit = 5) {
        const nodeId = `guest:${profileId}`;
        const scores = new Map();
        const reasons = new Map();
        const appearedOn = this.getNeighbors(nodeId, "appeared_on");
        for (const podcastId of appearedOn) {
            const coGuests = this.getNeighbors(podcastId, "appeared_on")
                .filter((g) => g !== nodeId);
            for (const coGuest of coGuests) {
                const guestId = coGuest.replace("guest:", "");
                const currentScore = scores.get(guestId) || 0;
                scores.set(guestId, currentScore + 1);
                if (!reasons.has(guestId)) {
                    reasons.set(guestId, []);
                }
                const podcastName = this.getNodeData(podcastId)?.name || "a podcast";
                reasons.get(guestId).push(`Appeared on ${podcastName}`);
            }
        }
        const similar = this.getNeighbors(nodeId, "similar_to");
        for (const simGuest of similar) {
            const guestId = simGuest.replace("guest:", "");
            const edge = this.getEdge(nodeId, simGuest);
            const currentScore = scores.get(guestId) || 0;
            const weight = edge?.weight || 0.5;
            scores.set(guestId, currentScore + weight);
            if (!reasons.has(guestId)) {
                reasons.set(guestId, []);
            }
            const shared = edge?.metadata?.sharedExpertise || ["similar expertise"];
            reasons.get(guestId).push(`Shares expertise in ${shared.slice(0, 2).join(", ")}`);
        }
        const sorted = Array.from(scores.entries())
            .sort((a, b) => b[1] - a[1])
            .slice(0, limit);
        return sorted.map(([guestId, score]) => ({
            guestId,
            reason: [...new Set(reasons.get(guestId) || [])].join("; "),
            score,
        }));
    }
    async findTrustPath(fromProfileId, toProfileId) {
        const start = `guest:${fromProfileId}`;
        const end = `guest:${toProfileId}`;
        if (!this.adjacencyList.has(start) || !this.adjacencyList.has(end)) {
            return null;
        }
        const queue = [{ node: start, path: [start] }];
        const visited = new Set();
        while (queue.length > 0) {
            const { node, path } = queue.shift();
            if (node === end) {
                return path.map((n) => n.replace("guest:", "").replace("podcast:", ""));
            }
            if (visited.has(node))
                continue;
            visited.add(node);
            const neighbors = this.adjacencyList.get(node);
            if (neighbors) {
                for (const [neighbor] of Array.from(neighbors.entries())) {
                    if (!visited.has(neighbor)) {
                        queue.push({ node: neighbor, path: [...path, neighbor] });
                    }
                }
            }
        }
        return null;
    }
    async getNetworkStats(profileId) {
        const nodeId = `guest:${profileId}`;
        if (!this.adjacencyList.has(nodeId)) {
            return { connections: 0, reach: 0, centrality: 0, communities: [] };
        }
        const directConnections = this.adjacencyList.get(nodeId).size;
        const visited = new Set();
        visited.add(nodeId);
        const neighbors = this.getAllNeighbors(nodeId);
        for (const n of Array.from(neighbors)) {
            visited.add(n);
        }
        for (const n of Array.from(neighbors)) {
            const secondHop = this.getAllNeighbors(n);
            for (const sh of Array.from(secondHop)) {
                visited.add(sh);
            }
        }
        const communities = this.identifyCommunities(nodeId);
        return {
            connections: directConnections,
            reach: visited.size - 1,
            centrality: this.calculateCentrality(nodeId),
            communities,
        };
    }
    async getCommunityMembers(communityType, value, limit = 20) {
        const members = [];
        for (const [nodeId, edges] of Array.from(this.adjacencyList.entries())) {
            if (!nodeId.startsWith("guest:"))
                continue;
            const data = edges.nodeData;
            if (!data)
                continue;
            if (communityType === "country" && data.country === value) {
                members.push(nodeId.replace("guest:", ""));
            }
            else if (communityType === "expertise" && data.expertise?.includes(value)) {
                members.push(nodeId.replace("guest:", ""));
            }
        }
        return members.slice(0, limit);
    }
    getNeighbors(nodeId, edgeType) {
        const edges = this.adjacencyList.get(nodeId);
        if (!edges)
            return [];
        return Array.from(edges.entries())
            .filter(([, edge]) => edge.type === edgeType)
            .map(([target]) => target);
    }
    getAllNeighbors(nodeId) {
        const edges = this.adjacencyList.get(nodeId);
        if (!edges)
            return [];
        return Array.from(edges.keys());
    }
    getEdge(source, target) {
        return this.adjacencyList.get(source)?.get(target);
    }
    getNodeData(nodeId) {
        const edges = this.adjacencyList.get(nodeId);
        if (!edges)
            return null;
        return edges.nodeData;
    }
    identifyCommunities(nodeId) {
        const data = this.getNodeData(nodeId);
        if (!data)
            return [];
        const communities = [];
        if (data.country) {
            communities.push(`${data.country} Community`);
        }
        if (data.expertise) {
            communities.push(...data.expertise.slice(0, 2).map((e) => `${e} Network`));
        }
        return communities;
    }
    calculateCentrality(nodeId) {
        const direct = this.adjacencyList.get(nodeId)?.size || 0;
        const twoHop = new Set();
        const neighbors = this.getAllNeighbors(nodeId);
        for (const n of neighbors) {
            const secondHop = this.getAllNeighbors(n);
            for (const sh of secondHop) {
                if (sh !== nodeId) {
                    twoHop.add(sh);
                }
            }
        }
        return direct + twoHop.size * 0.5;
    }
    getStats() {
        let edges = 0;
        let guests = 0;
        let podcasts = 0;
        for (const [nodeId] of Array.from(this.adjacencyList.entries())) {
            if (nodeId.startsWith("guest:"))
                guests++;
            if (nodeId.startsWith("podcast:"))
                podcasts++;
            edges += this.adjacencyList.get(nodeId).size;
        }
        return {
            nodes: this.adjacencyList.size,
            edges: edges / 2,
            guests,
            podcasts,
        };
    }
};
exports.GraphService = GraphService;
exports.GraphService = GraphService = GraphService_1 = __decorate([
    (0, common_1.Injectable)(),
    __metadata("design:paramtypes", [prisma_service_1.PrismaService])
], GraphService);
//# sourceMappingURL=graph.service.js.map