import { defaultBaseLanguage } from "@/src/constants/common";
import { find } from "lodash";

export const localizeRelation = (relation: any, language: string) => {
    if (!relation || !language || language === defaultBaseLanguage) return relation;

    const localized = relation.languages?.[language];
    if (!localized) return relation;

    const mergedRelation = { ...relation };

    Object.keys(localized).forEach(key => {
        if (localized[key] && typeof localized[key] === 'object' && !Array.isArray(localized[key]) && mergedRelation[key]) {
            mergedRelation[key] = { ...mergedRelation[key], ...localized[key] };
        } else if (localized[key]) {
            mergedRelation[key] = localized[key];
        }
    });

    return mergedRelation;
}

export const resolveRelation = ({
    pageData,
    relationTargets,
    pageRef,
    entityType,
    relationKey,
    targetRel,
    language = defaultBaseLanguage,
}: {
    pageData?: any;
    relationTargets?: any;
    pageRef?: string;
    entityType?: string;
    relationKey?: string;
    targetRel?: any;
    language?: string;
}) => {
    const relations = pageData?.relation || pageData?.[0]?.blockValues?.relation || [];
    let rel = targetRel;

    if (!rel) {
        if (relationKey) {
            rel = find(relations, { relationKey }) || find(relations, { fieldKey: relationKey }) || find(relations, { componentKey: relationKey });
        } else {
            rel = find(relations, { pageReference: pageRef, entityType });
        }
    }

    if (!rel) return { data: null, relation: null };

    let data;
    let relation = localizeRelation(rel, language);

    if (rel.isRelation) {
        data = resolveRelationTargets({ relation, relationTargets, overrideTargetData: true });
    } else {
        const key = rel.relationKey || rel.fieldKey;
        data = rel[key] || rel[rel.fieldKey] || rel;
    }
    return { data, relation };
};

export const resolveRelationTargets = ({ relation, relationTargets, overrideTargetData = false }: { relation: any, relationTargets: any, overrideTargetData?: boolean }) => {
    if (!relation || !relationTargets) return [];
    const entityType = relation.entityType;
    const targets = relation.targets || [];
    const allTargetsOfThisType = relationTargets[entityType] || [];

    return targets.map((t: any) => {
        const fullTarget = allTargetsOfThisType.find((at: any) => at._id === t.id);

        if (overrideTargetData) {
            return { ...fullTarget, ...t };
        }

        return { ...t, ...fullTarget };
    });
};

export const resolveDynamicComponents = ({ pageData, relationTargets, language = defaultBaseLanguage }: { pageData: any, relationTargets: any, language?: string }) => {
    const relations = pageData?.relation || pageData?.[0]?.blockValues?.relation || [];
    return relations
        .filter((rel: any) => rel.componentKey || rel.entityType)
        .map((rel: any) => {
            const componentKey = rel.componentKey || rel?.entityType;
            const key = rel.relationKey || rel.fieldKey;
            const { data, relation } = resolveRelation({ pageData, relationTargets, targetRel: rel, language });
            return {
                componentKey,
                data,
                relation,
                meta: rel,
                key
            };
        });
};