import { defineStore } from 'pinia';
import { ref, computed } from 'vue';

export const useWPSStore = defineStore('wps', () => {
    const connectionStatus = ref<'connected' | 'disconnected'>('disconnected');
    const activeDocument = ref<any>(null);
    const documents = ref<any[]>([]);
    const paragraphContent = ref<any>({
        text: '',
        html: '',
        revisions: [],
        comments: [],
        hasRevisions: false,
        hasComments: false
    });

    const hasUnsavedChanges = ref(false);
    const autoSync = ref(true);

    const isConnected = computed(() => connectionStatus.value === 'connected');
    const hasRevisions = computed(() => paragraphContent.value.revisions.length > 0);
    const hasComments = computed(() => paragraphContent.value.comments.length > 0);
    const canEdit = computed(() => isConnected.value && !!activeDocument.value);

    const setupEventListeners = () => {
        window.electronAPI.onWPSStatusChange((_event, status) => {
            connectionStatus.value = status.connected ? 'connected' : 'disconnected';
            documents.value = status.documents || [];
            activeDocument.value = status.activeDocument || null;
        });

        window.electronAPI.onDocumentsListChange((_event, docs) => {
            documents.value = docs;
        });

        window.electronAPI.onActiveDocumentChange((_event, doc) => {
            activeDocument.value = doc;
            hasUnsavedChanges.value = false;
        });

        window.electronAPI.onFullParagraphContentChange((_event, content) => {
            paragraphContent.value = content;
            hasUnsavedChanges.value = false;
        });
    };

    const refreshParagraph = async (): Promise<boolean> => {
        if (!isConnected.value) return false;

        try {
            const content = await window.electronAPI.getFullParagraphContent();
            paragraphContent.value = content;
            hasUnsavedChanges.value = false;
            return true;
        } catch (error) {
            console.error('Failed to refresh paragraph:', error);
            return false;
        }
    };

    const updateParagraph = async (content: string) => {
        if (!isConnected.value) return { success: false, error: 'WPS not connected' };

        try {
            const result = await window.electronAPI.updateParagraphWithRevisions(content);
            if (result.success) {
                hasUnsavedChanges.value = false;
                await refreshParagraph();
            }
            return result;
        } catch (error: any) {
            return { success: false, error: error.message };
        }
    };

    const navigateParagraph = async (direction: 'prev' | 'next') => {
        if (!isConnected.value) return false;
        return await window.electronAPI.navigateParagraph(direction);
    };

    return {
        connectionStatus,
        activeDocument,
        documents,
        paragraphContent,
        hasUnsavedChanges,
        autoSync,
        isConnected,
        hasRevisions,
        hasComments,
        canEdit,
        setupEventListeners,
        refreshParagraph,
        updateParagraph,
        navigateParagraph
    };
});