import { defaultError, defaultFilters, testFilters, transformObjectWithOptions, DEFAULT_NETWORK_OPTIONS } from './async-iterator.js';
import { run } from './commands/run.js';
import { createCacheProvider, DEFAULT_CACHE_CONFIG } from './iterator-cache.js';
const dummyLogger = {
    info: () => { },
    warn: () => { },
    error: () => { }
};
export const removeEmptyObjects = (obj) => {
    if (obj === null || obj === undefined)
        return obj;
    for (const key in obj) {
        const val = obj[key];
        if (val === null || val === undefined)
            continue;
        if (typeof val === 'object' ||
            (key == 'value' && typeof val === 'number' && val === 0 || key == 'base64')) {
            obj[key] = removeEmptyObjects(obj[key]);
            if (Object.keys(obj[key]).length === 0) {
                delete obj[key];
            }
        }
    }
    return obj;
};
export function createLLMTransformer(options, logger = dummyLogger, cacheConfig) {
    const mergedCacheConfig = { ...DEFAULT_CACHE_CONFIG, ...cacheConfig };
    const cacheProvider = createCacheProvider(mergedCacheConfig);
    return async (input, jsonPath) => {
        logger.info(`Transforming field at path: ${jsonPath}`);
        logger.info(`Input: ${input}`);
        logger.info(`Using prompt: ${options.prompt}`);
        const kbotTask = {
            ...options,
            prompt: `${options.prompt}\n\nText to transform: "${input}"`,
        };
        const cacheKeyObj = removeEmptyObjects({
            prompt: kbotTask.prompt,
            model: kbotTask.model,
            router: kbotTask.router,
            mode: kbotTask.mode,
            filters: [],
            tools: []
        });
        try {
            if (mergedCacheConfig.enabled) {
                const cachedResponse = await cacheProvider.get(cacheKeyObj, 'llm-responses');
                if (cachedResponse?.content) {
                    logger.info(`Using cached LLM response for prompt: ${kbotTask.prompt.substring(0, 100)}...`);
                    return cachedResponse.content;
                }
            }
            const results = await run(kbotTask);
            if (results && results.length > 0 && typeof results[0] === 'string') {
                const result = results[0].trim();
                if (mergedCacheConfig.enabled) {
                    await cacheProvider.set(cacheKeyObj, 'llm-responses', { content: result }, { expiration: mergedCacheConfig.expiration });
                    logger.info(`Cached LLM response for prompt: ${kbotTask.prompt.substring(0, 100)}...`);
                }
                logger.info(`Result: ${result}`);
                return result;
            }
            logger.warn(`No valid result received for ${jsonPath}, returning original`);
            return input;
        }
        catch (error) {
            logger.error(`Error calling LLM API: ${error.message}`, error);
            return input;
        }
    };
}
export function createIterator(obj, optionsMixin, globalOptions = {}) {
    const { network = {}, errorCallback = defaultError, filterCallback = testFilters(defaultFilters()), transformerFactory, logger = dummyLogger, cacheConfig, onTransform, onTransformed } = globalOptions;
    const networkOptions = {
        ...DEFAULT_NETWORK_OPTIONS,
        ...network
    };
    const mergedCacheConfig = { ...DEFAULT_CACHE_CONFIG, ...cacheConfig };
    const cacheProvider = createCacheProvider(mergedCacheConfig);
    const objCacheNamespace = 'transformed-objects';
    const defaultTransformerFactory = (options) => {
        return async (input) => input;
    };
    const createTransformer = transformerFactory || defaultTransformerFactory;
    const createObjectCacheKey = (data, mappings) => {
        return removeEmptyObjects({
            data: JSON.stringify(data),
            mappings: mappings.map(m => ({
                jsonPath: m.jsonPath,
                targetPath: m.targetPath,
                options: {
                    model: optionsMixin.model,
                    router: optionsMixin.router,
                    mode: optionsMixin.mode,
                    prompt: m.options?.prompt
                }
            }))
        });
    };
    const deepMerge = (target, source) => {
        for (const key in source) {
            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
                if (!target[key])
                    target[key] = {};
                deepMerge(target[key], source[key]);
            }
            else {
                target[key] = source[key];
            }
        }
    };
    return {
        createTransformer,
        transform: async (mappings) => {
            // *** Object Cache Check (Start) ***
            let objectCacheKey;
            if (mergedCacheConfig.enabled) {
                objectCacheKey = createObjectCacheKey(obj, mappings);
                const cachedObject = await cacheProvider.get(objectCacheKey, objCacheNamespace);
                if (cachedObject?.content) {
                    logger.info('Using cached transformed object');
                    Object.keys(obj).forEach(key => delete obj[key]);
                    deepMerge(obj, cachedObject.content);
                    return;
                }
            }
            // *** Object Cache Check (End) ***
            for (const mapping of mappings) {
                const mergedOptions = { ...optionsMixin, ...mapping.options };
                const { jsonPath, targetPath = null } = mapping;
                const transformer = createTransformer(mergedOptions);
                await transformObjectWithOptions(obj, transformer, {
                    jsonPath,
                    targetPath,
                    network: networkOptions,
                    errorCallback,
                    filterCallback,
                    onTransform,
                    onTransformed,
                    kbotOptions: mergedOptions
                });
            }
            // *** Object Cache Setting (Start) ***
            if (mergedCacheConfig.enabled && objectCacheKey) {
                await cacheProvider.set(objectCacheKey, objCacheNamespace, { content: obj }, { expiration: mergedCacheConfig.expiration });
                logger.info('Cached transformed object');
            }
            // *** Object Cache Setting (End) ***
        }
    };
}
export async function transformWithMappings(obj, createTransformer, mappings, globalOptions = {}) {
    const optionsWithTransformer = {
        ...globalOptions,
        transformerFactory: createTransformer
    };
    const iterator = createIterator(obj, {}, optionsWithTransformer);
    await iterator.transform(mappings);
}
/**
 * Simplified transformation function that only requires the target object and field mappings.
 * All other options are optional with sensible defaults.
 *
 * @param obj - The object to transform
 * @param mappings - Field mappings defining what to transform and how
 * @param optionsMixin - Optional global options to apply to all transformations
 * @param options - Optional advanced configuration
 * @returns The transformed object (also modifies the original)
 */
export async function transform(obj, mappings, optionsMixin = {}, options = {}) {
    const iterator = createIterator(obj, optionsMixin, options);
    await iterator.transform(mappings);
    return obj;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterator.js","sourceRoot":"","sources":["../src/iterator.ts"],"names":[],"mappings":"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"}