SOURCE

import { isEqual } from "lodash";


// 定义枚举类型
export enum TranslateType {
    SpaceName = 'SpaceName',
    SpaceDescription = 'SpaceDescription',
    DirectoryName = 'DirectoryName'
}

export interface KeyWorkAndType {
    keyName: string;
    type: TranslateType
}

export interface TranslateItem {
    keyworks: string;
    name: string;
    spaceId?: string;
    type: TranslateType;
}

interface ObjType {
    [key: string]: any
}


function generateRandomString(length: number): string {
    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    return Array.from({ length }, () => characters[Math.floor(Math.random() * characters.length)]).join('');
}

const modifyTranslationData = (data: TranslateItem[]): Promise<TranslateItem[]> => {
    return new Promise((resolve, reject) => {
        try {
            const processedData = data.map((item) => ({
              ...item,
                keyworks: item.keyworks || generateRandomString(8)
            }));
            resolve(processedData);
        } catch (error) {
            reject(error);
        }
    });
}

export class ObjectMerger {
    // 接收的两个对象参数
    private oldData: ObjType;
    private newData: ObjType;
    // 用于指定需要比较的键的数组
    private compareKeys: string[];
    // 用于翻译比较的键的数组
    private translateDiffKeys: string[];
    // 包含键名和对应类型的数组
    private keyWorkAndType: { keyName: string; type: TranslateType }[];
    // 空间ID，类型为字符串
    private spaceId: string;
    // 新增私有属性，用于缓存比较结果
    private _isEqual: boolean = true;

    // 构造函数，用于接收并初始化六个参数
    constructor(oldData: ObjType, newData: ObjType, compareKeys: string[], translateDiffKeys: string[], keyWorkAndType: { keyName: string; type: TranslateType }[], spaceId: string) {
        this.oldData = oldData;
        this.newData = newData;
        this.compareKeys = compareKeys;
        this.translateDiffKeys = translateDiffKeys;
        this.keyWorkAndType = keyWorkAndType;
        this.spaceId = spaceId;
        // 初始化时计算比较结果并缓存
        this._isEqual = this.areObjectsEqual();
    }

    // 方法：重新设置第一个对象的值
    setOldData(data: ObjType) {
        this.oldData = data;
        // 设置完后更新比较结果缓存
        this._isEqual = this.areObjectsEqual();
    }

    // 方法：重新设置第二个对象的值
    setNewData(data: ObjType) {
        this.newData = data;
        // 设置完后更新比较结果缓存
        this._isEqual = this.areObjectsEqual();
    }

    // 新增只读属性，通过get访问器实现，外部只能读取不能修改，用于实时获取比较结果是否变化
    get isEqual(): boolean {
        return this._isEqual;
    }

    // 方法：比较两个对象指定键对应的值是否相等，根据类中保存的compareKeys、translateDiffKeys数组以及keyWorkAndType进行相关逻辑处理，同时结合spaceId（此处可按需扩展），全部相等返回true，否则返回false
    areObjectsEqual(): boolean {
        for (const key of this.compareKeys) {
            if (!Object.prototype.hasOwnProperty.call(this.oldData, key) ||!Object.prototype.hasOwnProperty.call(this.newData, key)) {
                return false;
            }
            if (!isEqual(this.oldData[key], this.newData[key])) {
                return false;
            }
        }

        return true;
    }

    // 新增方法：processWithDetails，整合之前提供的逻辑
    async upDataTranslate(): Promise<TranslateItem[] | []> {
        // 校验translateDiffKeys和keyWorkAndType长度是否相等
        if (this.translateDiffKeys.length!== this.keyWorkAndType.length) {
            throw new Error('The number of elements in keys array and details array must be equal');
        }

        console.log('this.oldData', this.oldData)
        console.log('this.newData', this.newData)

        const oldObj:ObjType = {}
        const newObj:ObjType = {}
        this.translateDiffKeys.forEach((item)=> {
            oldObj[item] = this.oldData[item]
            newObj[item] = this.newData[item]
        })

        this.keyWorkAndType.forEach((item)=> {
            oldObj[item.keyName] = this.oldData[item.keyName]
            newObj[item.keyName] = this.newData[item.keyName]
        })

        console.log('oldObj', oldObj)
        console.log('newObj', newObj)
        
        for (const key of this.translateDiffKeys) {
            if (!(key in oldObj && key in newObj)) {
                throw new Error(`Key ${key} is not a valid key in the provided objects`);
            }
        }

        const translateData: TranslateItem[] = [];
        // 比较两个对象对应键的属性值，收集需要变更的数据
        for (const [index, objKeys] of this.translateDiffKeys.entries()) {
            if (!isEqual(oldObj[objKeys], newObj[objKeys])) {
                translateData.push({
                    keyworks: this.keyWorkAndType[index].keyName,
                    name: newObj[objKeys],
                    spaceId: this.spaceId,
                    type: this.keyWorkAndType[index].type
                });
            }
        }
        console.log('需要变更的数据', translateData);
        if (translateData.length) {
            return await modifyTranslationData(translateData);
        }
        return [];
    }
}