const {
    getProfileCollections,
    getProfileStats,
    achievementRequirementsMet,
    isStatBackfillableAchievement
} = require("./profileSystem");

const {
    getUnixTime
} = require("./cookieEconomy");


function getActiveDefinitions(
    achievementConfig
) {
    return achievementConfig
        .find({
            active: {
                $ne: false
            }
        })
        .toArray();
}


async function reconcileUserAchievements({
    guildId,
    userId,
    dryRun = false
}) {
    const {
        achievements,
        achievementConfig
    } = getProfileCollections();

    const [
        statsDocument,
        definitions,
        achievementDocument
    ] = await Promise.all([
        getProfileStats(
            userId,
            guildId
        ),

        getActiveDefinitions(
            achievementConfig
        ),

        achievements.findOne({
            userId,
            guildId
        })
    ]);

    const unlocked = {
        ...(achievementDocument?.unlocked ?? {})
    };

    const additions = {};

    let skippedEventOnly = 0;


    /*
     * ========================================================
     * NORMAL / STAT-BACKED ACHIEVEMENTS
     * ========================================================
     */

    const normalDefinitions =
        definitions.filter(
            definition =>
                definition.measure !==
                "achievementPercentage"
        );


    for (const definition of normalDefinitions) {
        if (
            unlocked[
            definition.achievementId
            ]
        ) {
            continue;
        }

        if (
            !isStatBackfillableAchievement(
                definition
            )
        ) {
            skippedEventOnly++;
            continue;
        }


        if (
            !achievementRequirementsMet(
                statsDocument,
                definition
            )
        ) {
            continue;
        }


        const timestamp =
            getUnixTime();


        additions[
            definition.achievementId
        ] = timestamp;


        unlocked[
            definition.achievementId
        ] = timestamp;
    }


    /*
     * ========================================================
     * COLLECTOR ACHIEVEMENTS
     * ========================================================
     *
     * Only stat-backed achievements count toward the
     * collectible denominator.
     *
     * This intentionally matches profileSystem.js.
     */

    const collectibleDefinitions =
        definitions.filter(
            definition =>
                isStatBackfillableAchievement(
                    definition
                )
        );


    const unlockedCollectible =
        collectibleDefinitions.filter(
            definition =>
                Boolean(
                    unlocked[
                    definition.achievementId
                    ]
                )
        ).length;


    const percentage =
        collectibleDefinitions.length > 0
            ? unlockedCollectible /
            collectibleDefinitions.length
            : 0;


    const collectorDefinitions =
        definitions.filter(
            definition =>
                definition.measure ===
                "achievementPercentage"
        );


    for (const definition of collectorDefinitions) {
        if (
            unlocked[
            definition.achievementId
            ]
        ) {
            continue;
        }


        if (
            percentage <
            Number(
                definition.target ?? 0
            )
        ) {
            continue;
        }


        const timestamp =
            getUnixTime();


        additions[
            definition.achievementId
        ] = timestamp;


        unlocked[
            definition.achievementId
        ] = timestamp;
    }


    /*
     * ========================================================
     * WRITE
     * ========================================================
     */

    const additionEntries =
        Object.entries(
            additions
        );


    if (
        !dryRun &&
        additionEntries.length > 0
    ) {
        const set = {};

        for (
            const [
                achievementId,
                timestamp
            ]
            of additionEntries
        ) {
            set[
                `unlocked.${achievementId}`
            ] = timestamp;
        }

        await achievements.updateOne(
            {
                userId,
                guildId
            },
            {
                $setOnInsert: {
                    userId,
                    guildId
                },

                $set: set
            },
            {
                upsert: true
            }
        );

        console.log(
            `[ProfileMaintenance] Reconciled ${additionEntries.length} achievement(s) for ${userId}: ${additionEntries
                .map(
                    ([achievementId]) =>
                        achievementId
                )
                .join(", ")}`
        );
    }


    if (
        dryRun &&
        additionEntries.length > 0
    ) {
        console.log(
            `[ProfileMaintenance] Dry run: ${userId} would unlock ${additionEntries.length} achievement(s): ${additionEntries
                .map(
                    ([achievementId]) =>
                        achievementId
                )
                .join(", ")}`
        );
    }


    return {
        userId,

        checked:
            definitions.length,

        unlocked:
            additionEntries.length,

        skippedEventOnly,

        dryRun,

        achievementIds:
            additionEntries.map(
                ([achievementId]) =>
                    achievementId
            )
    };
}


async function reconcileAllAchievements({
    guildId,
    dryRun = false
}) {
    const {
        stats
    } = getProfileCollections();


    const userIds =
        await stats.distinct(
            "userId",
            {
                guildId
            }
        );


    const summary = {
        users:
            userIds.length,

        unlocked:
            0,

        skippedEventOnly:
            0,

        results: []
    };


    for (const userId of userIds) {
        const result =
            await reconcileUserAchievements({
                guildId,
                userId,
                dryRun
            });


        summary.unlocked +=
            result.unlocked;


        summary.skippedEventOnly +=
            result.skippedEventOnly;


        summary.results.push(
            result
        );
    }


    return summary;
}


async function auditProfileData(
    guildId
) {
    const {
        stats,
        achievements,
        achievementConfig,
        badges
    } = getProfileCollections();


    const [
        statDocuments,
        achievementDocuments,
        activeDefinitions,
        badgeDocuments
    ] = await Promise.all([
        stats.find({
            guildId
        }).toArray(),

        achievements.find({
            guildId
        }).toArray(),

        achievementConfig
            .find({
                active: {
                    $ne: false
                }
            })
            .toArray(),

        badges.find({
            guildId
        }).toArray()
    ]);


    const issues = [];


    /*
     * ========================================================
     * STATS DOCUMENT VALIDATION
     * ========================================================
     */

    for (const document of statDocuments) {
        if (!document.userId) {
            issues.push(
                "Stats document missing userId."
            );

            continue;
        }


        /*
         * ----------------------------------------------------
         * GAME TOTALS
         * ----------------------------------------------------
         */

        const total =
            document.games?.total ?? {};


        const played =
            Number(
                total.played ?? 0
            );


        const resolved =
            Number(
                total.won ?? 0
            )
            +
            Number(
                total.lost ?? 0
            )
            +
            Number(
                total.pushed ?? 0
            );


        if (
            played !==
            resolved
        ) {
            issues.push(
                `${document.userId}: games.total.played (${played}) does not match W/L/P total (${resolved}).`
            );
        }


        for (
            const game
            of [
                "slots",
                "blackjack",
                "roulette",
                "heist"
            ]
        ) {
            const value =
                document.games?.[game] ?? {};


            const gamePlayed =
                Number(
                    value.played ?? 0
                );


            const gameResolved =
                Number(
                    value.won ?? 0
                )
                +
                Number(
                    value.lost ?? 0
                )
                +
                Number(
                    value.pushed ?? 0
                );


            if (
                gamePlayed !==
                gameResolved
            ) {
                issues.push(
                    `${document.userId}: games.${game}.played (${gamePlayed}) does not match W/L/P total (${gameResolved}).`
                );
            }
        }


        /*
         * ----------------------------------------------------
         * NON-NEGATIVE ECONOMY COUNTERS
         * ----------------------------------------------------
         */

        const nonNegativeFields = [
            document.economy
                ?.cookiesObtainedTotal,

            document.economy
                ?.cookiesLostTotal,

            document.economy
                ?.cookiesGivenTotal,

            document.economy
                ?.stolenTotal,

            document.economy
                ?.stolenFromMeTotal,

            document.economy
                ?.vaultStolenTotal
        ];


        if (
            nonNegativeFields.some(
                value =>
                    Number(
                        value ?? 0
                    ) < 0
            )
        ) {
            issues.push(
                `${document.userId}: one or more economy counters are negative.`
            );
        }


        /*
         * ----------------------------------------------------
         * ACTIVITY SCHEMA
         * ----------------------------------------------------
         */

        const activity =
            document.activity;


        if (!activity) {
            issues.push(
                `${document.userId}: activity object is missing.`
            );

            continue;
        }


        const currentDailyStreak =
            Number(
                activity.currentDailyStreak ?? 0
            );


        const bestDailyStreak =
            Number(
                activity.bestDailyStreak ?? 0
            );


        if (
            currentDailyStreak < 0 ||
            bestDailyStreak < 0
        ) {
            issues.push(
                `${document.userId}: activity streak counters cannot be negative.`
            );
        }


        if (
            currentDailyStreak >
            bestDailyStreak
        ) {
            issues.push(
                `${document.userId}: currentDailyStreak (${currentDailyStreak}) exceeds bestDailyStreak (${bestDailyStreak}).`
            );
        }


        /*
         * ----------------------------------------------------
         * DATE KEYS
         * ----------------------------------------------------
         */

        for (
            const field
            of [
                "lastActiveDate",
                "lastGameDate"
            ]
        ) {
            const value =
                activity[field];


            if (
                value !== null &&
                value !== undefined &&
                !isValidDateKey(
                    value
                )
            ) {
                issues.push(
                    `${document.userId}: activity.${field} has invalid date key "${value}".`
                );
            }
        }


        /*
         * ----------------------------------------------------
         * WEEK KEY
         * ----------------------------------------------------
         */

        if (
            activity.currentWeekKey !==
            null
            &&
            activity.currentWeekKey !==
            undefined
            &&
            !isValidWeekKey(
                activity.currentWeekKey
            )
        ) {
            issues.push(
                `${document.userId}: activity.currentWeekKey has invalid value "${activity.currentWeekKey}".`
            );
        }


        /*
         * ----------------------------------------------------
         * WEEKDAY COUNTERS
         * ----------------------------------------------------
         */

        const gamesByWeekday =
            activity.gamesByWeekday ?? {};


        const weekdays = [
            "monday",
            "tuesday",
            "wednesday",
            "thursday",
            "friday",
            "saturday",
            "sunday"
        ];


        for (const weekday of weekdays) {
            const value =
                Number(
                    gamesByWeekday[
                    weekday
                    ] ?? 0
                );


            if (
                !Number.isFinite(
                    value
                )
                ||
                value < 0
            ) {
                issues.push(
                    `${document.userId}: activity.gamesByWeekday.${weekday} is invalid.`
                );
            }
        }


        /*
         * ----------------------------------------------------
         * CURRENT WEEK DAYS
         * ----------------------------------------------------
         */

        const currentWeekDays =
            activity.currentWeekDays;


        if (
            !Array.isArray(
                currentWeekDays
            )
        ) {
            issues.push(
                `${document.userId}: activity.currentWeekDays is not an array.`
            );
        }

        else {
            const uniqueDays =
                new Set(
                    currentWeekDays
                );


            if (
                uniqueDays.size !==
                currentWeekDays.length
            ) {
                issues.push(
                    `${document.userId}: activity.currentWeekDays contains duplicate weekdays.`
                );
            }


            for (
                const weekday
                of currentWeekDays
            ) {
                if (
                    !weekdays.includes(
                        weekday
                    )
                ) {
                    issues.push(
                        `${document.userId}: activity.currentWeekDays contains invalid weekday "${weekday}".`
                    );
                }
            }
        }


        /*
         * ----------------------------------------------------
         * TIME BUCKETS
         * ----------------------------------------------------
         */

        const timeBuckets =
            activity.gamesByTimeBucket ?? {};


        for (
            const bucket
            of [
                "overnight",
                "morning",
                "afternoon",
                "evening"
            ]
        ) {
            const value =
                Number(
                    timeBuckets[
                    bucket
                    ] ?? 0
                );


            if (
                !Number.isFinite(
                    value
                )
                ||
                value < 0
            ) {
                issues.push(
                    `${document.userId}: activity.gamesByTimeBucket.${bucket} is invalid.`
                );
            }
        }


        /*
         * ----------------------------------------------------
         * SCHEMA VERSION
         * ----------------------------------------------------
         */

        if (
            Number(
                document
                    .profileSchemaVersion ?? 0
            ) < 2
        ) {
            issues.push(
                `${document.userId}: profileSchemaVersion is below 2.`
            );
        }
    }


    /*
     * ========================================================
     * ACHIEVEMENT DEFINITION VALIDATION
     * ========================================================
     */

    const achievementIds =
        new Set();


    for (
        const definition
        of activeDefinitions
    ) {
        /*
         * ----------------------------------------------------
         * ACHIEVEMENT ID
         * ----------------------------------------------------
         */

        if (
            !definition
                .achievementId
        ) {
            issues.push(
                "Active achievement definition missing achievementId."
            );

            continue;
        }


        if (
            achievementIds.has(
                definition.achievementId
            )
        ) {
            issues.push(
                `Duplicate active achievementId: ${definition.achievementId}.`
            );
        }


        achievementIds.add(
            definition.achievementId
        );


        /*
         * ----------------------------------------------------
         * COLLECTOR ACHIEVEMENTS
         * ----------------------------------------------------
         */

        if (
            definition.measure ===
            "achievementPercentage"
        ) {
            if (
                definition.target ===
                undefined
            ) {
                issues.push(
                    `${definition.achievementId}: target is missing.`
                );

                continue;
            }


            const target =
                Number(
                    definition.target
                );


            if (
                !Number.isFinite(
                    target
                )
                ||
                target < 0
                ||
                target > 1
            ) {
                issues.push(
                    `${definition.achievementId}: achievementPercentage target must be between 0 and 1.`
                );
            }


            continue;
        }

        /*
        * ----------------------------------------------------
        * EVENT ACHIEVEMENTS
        * ----------------------------------------------------
        */
            
        if (
            definition.measure ===
            "event"
        ) {
            if (
                !definition.eventType ||
                typeof definition.eventType !==
                "string"
            ) {
                issues.push(
                    `${definition.achievementId}: event achievement has no eventType.`
                );
            }


            if (
                !Array.isArray(
                    definition.eventConditions
                )
                ||
                definition.eventConditions.length ===
                0
            ) {
                issues.push(
                    `${definition.achievementId}: event achievement has no eventConditions.`
                );

                continue;
            }


            const validEventOperators = [
                "eq",
                "neq",
                "gt",
                "gte",
                "lt",
                "lte",
                "in",
                "not_in",
                "truthy",
                "falsy"
            ];


            for (
                const [
                    index,
                    condition
                ]
                of definition
                    .eventConditions
                    .entries()
            ) {
                if (
                    !condition ||
                    typeof condition !==
                    "object"
                ) {
                    issues.push(
                        `${definition.achievementId}: event condition ${index + 1} is invalid.`
                    );

                    continue;
                }


                if (
                    !condition.field
                ) {
                    issues.push(
                        `${definition.achievementId}: event condition ${index + 1} has no field.`
                    );
                }


                const operator =
                    String(
                        condition.operator ??
                        "eq"
                    ).toLowerCase();


                if (
                    !validEventOperators.includes(
                        operator
                    )
                ) {
                    issues.push(
                        `${definition.achievementId}: event condition ${index + 1} has unknown operator "${operator}".`
                    );
                }


                if (
                    [
                        "eq",
                        "neq",
                        "gt",
                        "gte",
                        "lt",
                        "lte",
                        "in",
                        "not_in"
                    ].includes(
                        operator
                    )
                    &&
                    condition.value ===
                    undefined
                ) {
                    issues.push(
                        `${definition.achievementId}: event condition ${index + 1} using "${operator}" is missing value.`
                    );
                }


                if (
                    [
                        "in",
                        "not_in"
                    ].includes(
                        operator
                    )
                    &&
                    !Array.isArray(
                        condition.value
                    )
                ) {
                    issues.push(
                        `${definition.achievementId}: event condition ${index + 1} using "${operator}" requires an array value.`
                    );
                }


                if (
                    [
                        "gt",
                        "gte",
                        "lt",
                        "lte"
                    ].includes(
                        operator
                    )
                    &&
                    !Number.isFinite(
                        Number(
                            condition.value
                        )
                    )
                ) {
                    issues.push(
                        `${definition.achievementId}: event condition ${index + 1} has a non-numeric comparison value.`
                    );
                }
            }


            continue;
        }

        /*
         * ----------------------------------------------------
         * COMPOSITE ACHIEVEMENTS
         * ----------------------------------------------------
         */

        if (
            definition.measure ===
            "all"
            ||
            definition.measure ===
            "any"
        ) {
            if (
                !Array.isArray(
                    definition.conditions
                )
                ||
                definition.conditions.length ===
                0
            ) {
                issues.push(
                    `${definition.achievementId}: composite achievement has no conditions.`
                );

                continue;
            }


            const validOperators = [
                "eq",
                "neq",
                "gt",
                "gte",
                "lt",
                "lte",
                "includes",
                "not_includes",
                "truthy",
                "falsy"
            ];


            for (
                const [
                    index,
                    condition
                ]
                of definition
                    .conditions
                    .entries()
            ) {
                if (
                    !condition
                    ||
                    typeof condition !==
                    "object"
                ) {
                    issues.push(
                        `${definition.achievementId}: condition ${index + 1} is invalid.`
                    );

                    continue;
                }


                if (
                    !condition.stat
                ) {
                    issues.push(
                        `${definition.achievementId}: condition ${index + 1} has no stat path.`
                    );
                }


                const operator =
                    String(
                        condition.operator ??
                        "gte"
                    ).toLowerCase();


                if (
                    !validOperators.includes(
                        operator
                    )
                ) {
                    issues.push(
                        `${definition.achievementId}: condition ${index + 1} has unknown operator "${operator}".`
                    );
                }


                /*
                 * Operators that compare against a value
                 * require condition.value.
                 */

                if (
                    [
                        "eq",
                        "neq",
                        "gt",
                        "gte",
                        "lt",
                        "lte",
                        "includes",
                        "not_includes"
                    ].includes(
                        operator
                    )
                    &&
                    condition.value ===
                    undefined
                ) {
                    issues.push(
                        `${definition.achievementId}: condition ${index + 1} using "${operator}" is missing value.`
                    );
                }


                /*
                 * Numeric operators should use numeric
                 * comparison values.
                 */

                if (
                    [
                        "gt",
                        "gte",
                        "lt",
                        "lte"
                    ].includes(
                        operator
                    )
                    &&
                    !Number.isFinite(
                        Number(
                            condition.value
                        )
                    )
                ) {
                    issues.push(
                        `${definition.achievementId}: condition ${index + 1} using "${operator}" has a non-numeric value.`
                    );
                }
            }


            /*
             * Composite achievements use their conditions
             * instead of a top-level stat/target.
             */

            continue;
        }


        /*
         * ----------------------------------------------------
         * NORMAL STAT-BACKED ACHIEVEMENTS
         * ----------------------------------------------------
         */

        if (
            definition.stat
        ) {
            if (
                definition.target ===
                undefined
            ) {
                issues.push(
                    `${definition.achievementId}: target is missing.`
                );

                continue;
            }


            const target =
                Number(
                    definition.target
                );


            if (
                !Number.isFinite(
                    target
                )
            ) {
                issues.push(
                    `${definition.achievementId}: target is not numeric.`
                );
            }


            continue;
        }


        /*
         * ----------------------------------------------------
         * EVENT-ONLY ACHIEVEMENTS
         * ----------------------------------------------------
         *
         * These aren't considered structurally invalid.
         *
         * Stage 4 will introduce proper event-condition
         * validation for them.
         */

        continue;
    }


    /*
     * ========================================================
     * ORPHANED ACHIEVEMENT DOCUMENTS
     * ========================================================
     */

    const statUsers =
        new Set(
            statDocuments.map(
                document =>
                    document.userId
            )
        );


    const orphanAchievementDocs =
        achievementDocuments.filter(
            document =>
                !statUsers.has(
                    document.userId
                )
        ).length;


    /*
     * ========================================================
     * BADGES
     * ========================================================
     */

    const claimedBadges =
        badgeDocuments.filter(
            badge =>
                Boolean(
                    badge.ownerId
                )
        ).length;


    return {
        statDocuments:
            statDocuments.length,

        achievementDocuments:
            achievementDocuments.length,

        activeAchievements:
            activeDefinitions.length,

        badgeDocuments:
            badgeDocuments.length,

        claimedBadges,

        orphanAchievementDocs,

        issueCount:
            issues.length,

        issues
    };
}


function isValidDateKey(
    value
) {
    if (
        typeof value !==
        "string"
    ) {
        return false;
    }


    if (
        !/^\d{4}-\d{2}-\d{2}$/.test(
            value
        )
    ) {
        return false;
    }


    const date =
        new Date(
            `${value}T00:00:00Z`
        );


    if (
        Number.isNaN(
            date.getTime()
        )
    ) {
        return false;
    }


    return (
        date
            .toISOString()
            .slice(
                0,
                10
            )
        ===
        value
    );
}


function isValidWeekKey(
    value
) {
    return (
        typeof value ===
        "string"
        &&
        /^\d{4}-W(?:0[1-9]|[1-4]\d|5[0-3])$/.test(
            value
        )
    );
}


module.exports = {
    reconcileUserAchievements,
    reconcileAllAchievements,
    auditProfileData
};