import { v4 as uuidv4 } from 'uuid';
import { BaseTool } from './BaseTool';
import { Observation } from '../types/types';
import { ParametersType, TypeMap, Parameter } from '../types/tool_types';
import { DocumentOptions, Docs } from '../../../../documents/Documents';

/**
 * List of supported document types.
 */
const supportedDocumentTypes = [
    'text',
    'image',
    'pdf',
    'video',
    'audio',
    'web',
    'map',
    'equation',
    'functionPlot',
    'dataViz',
    'chat',
    // Add more document types as needed
];

/**
 * Description of document options for each type.
 */
const documentOptionsDescription = {
    text: ['title', 'backgroundColor', 'fontColor', 'text_align', 'layout', 'text_content'],
    image: ['title', 'backgroundColor', 'width', 'height', 'layout'],
    pdf: ['title', 'backgroundColor', 'width', 'height', 'layout'],
    video: ['title', 'backgroundColor', 'width', 'height', 'layout'],
    audio: ['title', 'backgroundColor', 'layout'],
    web: ['title', 'backgroundColor', 'width', 'height', 'layout', 'url'],
    // Include descriptions for other document types
};

const createAnyDocumentToolParams = [
    {
        name: 'document_type',
        type: 'string',
        description: `The type of the document to create. Supported types are: ${supportedDocumentTypes.join(', ')}`,
        required: true,
    },
    {
        name: 'data',
        type: 'string',
        description: 'The content or data of the document (e.g., text content, URL, etc.).',
        required: false,
    },
    {
        name: 'options',
        type: 'string',
        description: `A JSON string representing the document options. Available options depend on the document type. For example, for 'text' documents, options include: ${documentOptionsDescription['text'].join(', ')}.`,
        required: false,
    },
] as const;

type CreateAnyDocumentToolParamsType = typeof createAnyDocumentToolParams;

export class CreateAnyDocumentTool extends BaseTool<CreateAnyDocumentToolParamsType> {
    private _addLinkedDoc: (doc_type: string, data: string | undefined, options: DocumentOptions, id: string) => void;

    constructor(addLinkedDoc: (doc_type: string, data: string | undefined, options: DocumentOptions, id: string) => void) {
        super(
            'createAnyDocument',
            `Creates any type of document with the provided options and data. Supported document types are: ${supportedDocumentTypes.join(', ')}.`,
            createAnyDocumentToolParams,
            'Provide the document type, data, and options for the document. Options should be a valid JSON string containing the document options specific to the document type.',
            'Creates any type of document with the provided options and data.'
        );
        this._addLinkedDoc = addLinkedDoc;
    }

    async execute(args: ParametersType<CreateAnyDocumentToolParamsType>): Promise<Observation[]> {
        try {
            const documentType = args.document_type.toLowerCase();
            let options: DocumentOptions = {};

            if (!supportedDocumentTypes.includes(documentType)) {
                throw new Error(`Unsupported document type: ${documentType}. Supported types are: ${supportedDocumentTypes.join(', ')}.`);
            }

            if (args.options) {
                try {
                    options = JSON.parse(args.options as string) as DocumentOptions;
                } catch (e) {
                    throw new Error('Options must be a valid JSON string.');
                }
            }

            const data = args.data as string | undefined;
            const id = uuidv4();

            // Validate and set default options based on document type
            switch (documentType) {
                case 'text':
                    if (!data) {
                        throw new Error('Data is required for text documents.');
                    }
                    options.title = options.title || 'New Text Document';
                    break;
                case 'image':
                case 'pdf':
                case 'video':
                case 'audio':
                case 'web':
                    if (!data) {
                        throw new Error(`Data (e.g., URL) is required for ${documentType} documents.`);
                    }
                    options.title = options.title || `New ${documentType.charAt(0).toUpperCase() + documentType.slice(1)} Document`;
                    break;
                // Add cases and default options for other document types as needed
                default:
                    break;
            }

            this._addLinkedDoc(documentType, data, options, id);

            return [{ type: 'text', text: `Created ${documentType} document with ID ${id}.` }];
        } catch (error) {
            return [{ type: 'text', text: 'Error creating document: ' + (error as Error).message }];
        }
    }
}