import { useState, useEffect } from 'react';
import { IPaywallProduct } from "@/api/resources/Paywall";
import { generateRealisticEmail } from "@/services/random-value/emailGenerator";
import { useTranslations } from "@/hooks/translations";
import { ELocalesPlacement } from "@/locales";

interface DisplayEmail {
    email: string;
    price: number;
    id: number;
    willBeRemoved: boolean;
}

export const useEmailsGeneration = (products: Array<IPaywallProduct & { weight: number }>) => {
    const { translate } = useTranslations(ELocalesPlacement.EmailGenerator);
    const [displayEmails, setDisplayEmails] = useState<DisplayEmail[]>([]);
    const [countBoughtEmails, setCountBoughtEmails] = useState(758);
    const maxEmails = 4;
    const minEmails = 3;

    const getRandomProduct = () => {
        const totalWeight = products.reduce((sum, product) => sum + (product.weight || 1), 0);
        let random = Math.random() * totalWeight;

        for (const product of products) {
            random -= (product.weight || 1);
            if (random <= 0) return product;
        }
        return products[0];
    };

    const createEmail = () => {
        const product = getRandomProduct();
        return {
            email: generateRealisticEmail(
                translate("firstNames").split(",") || [],
                translate("lastNames").split(",") || [],
                translate("domains").split(",") || []
            ),
            price: (product.trialPrice || 0) / 100,
            id: Date.now() + Math.random(),
            willBeRemoved: false
        };
    };

    useEffect(() => {
        const addEmails = () => {
            const count = Math.random() < 0.7 ? 1 : 2;
            const newEmails = Array(count).fill(null).map(createEmail);

            setDisplayEmails(prev => {
                const updatedEmails = [...prev, ...newEmails].slice(-maxEmails);

                if (updatedEmails.length < minEmails) {
                    const additionalCount = minEmails - updatedEmails.length;
                    const additionalEmails = Array(additionalCount).fill(null).map(createEmail);
                    return [...updatedEmails, ...additionalEmails];
                }

                return updatedEmails;
            });

            const deleteTime = 3000 + Math.random() * 6000;

            setTimeout(() => {
                setDisplayEmails(prev =>
                    prev.map(email =>
                        newEmails.includes(email)
                            ? { ...email, willBeRemoved: true }
                            : email
                    )
                );
            }, deleteTime - 1000);

            setTimeout(() => {
                setDisplayEmails(prev => {
                    const filteredEmails = prev.filter(email => !newEmails.includes(email));
                    setCountBoughtEmails(prev => prev + +(filteredEmails.length >= minEmails));
                    return filteredEmails.length >= minEmails ? (filteredEmails) : prev;
                });
            }, deleteTime);

            setTimeout(addEmails, 1000 + Math.random() * 3000);
        };

        setDisplayEmails(Array(minEmails).fill(null).map(createEmail));
        addEmails();

        return () => setDisplayEmails([]);
    }, [products]);

    return { displayEmails, countBoughtEmails };
};