// backend/functions/connect/handler.js
const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
const { DynamoDBDocumentClient, PutCommand } = require('@aws-sdk/lib-dynamodb');

const ddbClient = new DynamoDBClient();
const ddb = DynamoDBDocumentClient.from(ddbClient);

exports.handler = async (event) => {
    const connectionId = event.requestContext.connectionId;
    const timestamp = Date.now();

    try {
        // Verificar token de autenticación
        const auth = event.queryStringParameters?.Authorization;
        if (!auth) {
            return {
                statusCode: 401,
                body: 'Unauthorized'
            };
        }

        // Guardar conexión en DynamoDB
        await ddb.send(new PutCommand({
            TableName: process.env.CONNECTIONS_TABLE,
            Item: {
                connectionId,
                userId: event.requestContext.authorizer.claims.sub,
                timestamp,
                ttl: Math.floor(timestamp / 1000) + 24 * 60 * 60, // 24 horas
                status: 'CONNECTED'
            }
        }));

        return {
            statusCode: 200,
            body: 'Connected'
        };
    } catch (err) {
        console.error('Error:', err);
        return {
            statusCode: 500,
            body: 'Failed to connect: ' + JSON.stringify(err)
        };
    }
};

// backend/functions/disconnect/handler.js
const { DeleteCommand } = require('@aws-sdk/lib-dynamodb');

exports.handler = async (event) => {
    const connectionId = event.requestContext.connectionId;

    try {
        await ddb.send(new DeleteCommand({
            TableName: process.env.CONNECTIONS_TABLE,
            Key: {
                connectionId
            }
        }));

        return {
            statusCode: 200,
            body: 'Disconnected'
        };
    } catch (err) {
        console.error('Error:', err);
        return {
            statusCode: 500,
            body: 'Failed to disconnect: ' + JSON.stringify(err)
        };
    }
};

// backend/functions/message/handler.js
const { ApiGatewayManagementApiClient, PostToConnectionCommand } = require('@aws-sdk/client-apigatewaymanagementapi');
const { PutCommand, QueryCommand } = require('@aws-sdk/lib-dynamodb');

exports.handler = async (event) => {
    const connectionId = event.requestContext.connectionId;
    const domain = event.requestContext.domainName;
    const stage = event.requestContext.stage;

    const apiGateway = new ApiGatewayManagementApiClient({
        endpoint: `https://${domain}/${stage}`
    });

    try {
        const body = JSON.parse(event.body);
        const message = {
            messageId: uuid.v4(),
            connectionId,
            userId: event.requestContext.authorizer.claims.sub,
            message: body.message,
            timestamp: Date.now(),
            type: 'USER_MESSAGE'
        };

        // Guardar mensaje en DynamoDB
        await ddb.send(new PutCommand({
            TableName: process.env.MESSAGES_TABLE,
            Item: message
        }));

        // Obtener conexiones activas
        const connections = await ddb.send(new QueryCommand({
            TableName: process.env.CONNECTIONS_TABLE,
            IndexName: 'StatusIndex',
            KeyConditionExpression: '#status = :status',
            ExpressionAttributeNames: {
                '#status': 'status'
            },
            ExpressionAttributeValues: {
                ':status': 'CONNECTED'
            }
        }));

        // Enviar mensaje a todas las conexiones activas
        const sendMessages = connections.Items.map(async ({ connectionId }) => {
            try {
                await apiGateway.send(new PostToConnectionCommand({
                    ConnectionId: connectionId,
                    Data: JSON.stringify(message)
                }));
            } catch (err) {
                if (err.statusCode === 410) {
                    // Eliminar conexiones muertas
                    await ddb.send(new DeleteCommand({
                        TableName: process.env.CONNECTIONS_TABLE,
                        Key: { connectionId }
                    }));
                }
            }
        });

        await Promise.all(sendMessages);

        return {
            statusCode: 200,
            body: 'Message sent'
        };
    } catch (err) {
        console.error('Error:', err);
        return {
            statusCode: 500,
            body: 'Failed to send message: ' + JSON.stringify(err)
        };
    }
};

// backend/lib/dynamodb.js
const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
const { 
    DynamoDBDocumentClient, 
    PutCommand, 
    GetCommand, 
    QueryCommand, 
    DeleteCommand 
} = require('@aws-sdk/lib-dynamodb');

class ChatRepository {
    constructor() {
        const ddbClient = new DynamoDBClient();
        this.ddb = DynamoDBDocumentClient.from(ddbClient);
    }

    async saveConnection(connectionData) {
        return await this.ddb.send(new PutCommand({
            TableName: process.env.CONNECTIONS_TABLE,
            Item: {
                ...connectionData,
                ttl: Math.floor(Date.now() / 1000) + 24 * 60 * 60
            }
        }));
    }

    async removeConnection(connectionId) {
        return await this.ddb.send(new DeleteCommand({
            TableName: process.env.CONNECTIONS_TABLE,
            Key: { connectionId }
        }));
    }

    async getActiveConnections() {
        const result = await this.ddb.send(new QueryCommand({
            TableName: process.env.CONNECTIONS_TABLE,
            IndexName: 'StatusIndex',
            KeyConditionExpression: '#status = :status',
            ExpressionAttributeNames: {
                '#status': 'status'
            },
            ExpressionAttributeValues: {
                ':status': 'CONNECTED'
            }
        }));
        return result.Items;
    }

    async saveMessage(messageData) {
        return await this.ddb.send(new PutCommand({
            TableName: process.env.MESSAGES_TABLE,
            Item: {
                ...messageData,
                ttl: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60 // 30 días
            }
        }));
    }

    async getMessageHistory(userId, limit = 50) {
        const result = await this.ddb.send(new QueryCommand({
            TableName: process.env.MESSAGES_TABLE,
            IndexName: 'UserMessageIndex',
            KeyConditionExpression: 'userId = :userId',
            ExpressionAttributeValues: {
                ':userId': userId
            },
            Limit: limit,
            ScanIndexForward: false
        }));
        return result.Items;
    }

    async getConversationMessages(conversationId, limit = 50) {
        const result = await this.ddb.send(new QueryCommand({
            TableName: process.env.MESSAGES_TABLE,
            KeyConditionExpression: 'conversationId = :conversationId',
            ExpressionAttributeValues: {
                ':conversationId': conversationId
            },
            Limit: limit,
            ScanIndexForward: false
        }));
        return result.Items;
    }
}

module.exports = ChatRepository;

// backend/lib/websocket.js
const { ApiGatewayManagementApiClient, PostToConnectionCommand } = require('@aws-sdk/client-apigatewaymanagementapi');

class WebSocketManager {
    constructor(domainName, stage) {
        this.apiGateway = new ApiGatewayManagementApiClient({
            endpoint: `https://${domainName}/${stage}`
        });
    }

    async broadcast(connections, message) {
        const sendPromises = connections.map(({ connectionId }) =>
            this.sendMessage(connectionId, message)
        );
        return Promise.all(sendPromises);
    }

    async sendMessage(connectionId, message) {
        try {
            await this.apiGateway.send(new PostToConnectionCommand({
                ConnectionId: connectionId,
                Data: JSON.stringify(message)
            }));
            return true;
        } catch (err) {
            if (err.statusCode === 410) {
                return { staleConnection: connectionId };
            }
            throw err;
        }
    }
}

module.exports = WebSocketManager;

// backend/models/Message.js
class Message {
    constructor(data) {
        this.messageId = data.messageId;
        this.userId = data.userId;
        this.connectionId = data.connectionId;
        this.type = data.type;
        this.content = data.content;
        this.timestamp = data.timestamp || Date.now();
        this.metadata = data.metadata || {};
    }

    toJSON() {
        return {
            messageId: this.messageId,
            userId: this.userId,
            type: this.type,
            content: this.content,
            timestamp: this.timestamp,
            metadata: this.metadata
        };
    }

    static validateMessage(content) {
        if (!content || content.trim().length === 0) {
            throw new Error('Message content cannot be empty');
        }
        if (content.length > 1000) {
            throw new Error('Message content too long');
        }
        return true;
    }
}

// backend/models/Connection.js
class Connection {
    constructor(data) {
        this.connectionId = data.connectionId;
        this.userId = data.userId;
        this.timestamp = data.timestamp || Date.now();
        this.status = data.status || 'CONNECTED';
        this.metadata = data.metadata || {};
    }

    toJSON() {
        return {
            connectionId: this.connectionId,
            userId: this.userId,
            timestamp: this.timestamp,
            status: this.status,
            metadata: this.metadata
        };
    }
}

module.exports = {
    Message,
    Connection
};

// backend/functions/lexbot/handler.js
const { LexRuntimeV2Client, RecognizeTextCommand } = require("@aws-sdk/client-lex-runtime-v2");

class LexBotHandler {
    constructor() {
        this.lexClient = new LexRuntimeV2Client();
        this.botId = process.env.LEX_BOT_ID;
        this.botAliasId = process.env.LEX_BOT_ALIAS_ID;
        this.localeId = "en_US";
    }

    async processMessage(userId, message) {
        try {
            const params = {
                botId: this.botId,
                botAliasId: this.botAliasId,
                localeId: this.localeId,
                sessionId: userId,
                text: message,
            };

            const command = new RecognizeTextCommand(params);
            const response = await this.lexClient.send(command);

            return this.formatLexResponse(response);
        } catch (error) {
            console.error('Error processing message with Lex:', error);
            throw error;
        }
    }

    formatLexResponse(lexResponse) {
        if (lexResponse.messages && lexResponse.messages.length > 0) {
            return {
                type: 'BOT_RESPONSE',
                content: lexResponse.messages.map(msg => msg.content).join('\n'),
                intent: lexResponse.interpretations[0]?.intent?.name || 'Unknown',
                confidence: lexResponse.interpretations[0]?.nluConfidence || 0
            };
        }
        
        return {
            type: 'BOT_RESPONSE',
            content: "I'm sorry, I couldn't understand that.",
            intent: 'Unknown',
            confidence: 0
        };
    }
}

// Intent Handlers
const intentHandlers = {
    Greeting: async (event) => {
        const timeOfDay = getTimeOfDay();
        return {
            messages: [{
                content: `Good ${timeOfDay}! How can I help you today?`,
                contentType: 'PlainText'
            }]
        };
    },

    Help: async (event) => {
        return {
            messages: [{
                content: 'I can help you with:\n' +
                        '- Checking your order status\n' +
                        '- Account information\n' +
                        '- Delivery tracking\n' +
                        'Just let me know what you need!',
                contentType: 'PlainText'
            }]
        };
    },

    Status: async (event) => {
        const statusType = event.sessionState.intent.slots.StatusType;
        let response = '';

        switch (statusType.value?.interpretedValue) {
            case 'order':
                response = 'Your last order #12345 is being processed and will be shipped soon.';
                break;
            case 'account':
                response = 'Your account is active and in good standing.';
                break;
            case 'delivery':
                response = 'Your delivery is scheduled for tomorrow between 2-4 PM.';
                break;
            default:
                response = 'Please specify what type of status you would like to check.';
        }

        return {
            messages: [{
                content: response,
                contentType: 'PlainText'
            }]
        };
    }
};

function getTimeOfDay() {
    const hour = new Date().getHours();
    if (hour < 12) return 'morning';
    if (hour < 18) return 'afternoon';
    return 'evening';
}

// Lambda Handler
exports.handler = async (event) => {
    console.log('Received event:', JSON.stringify(event, null, 2));

    const intentName = event.sessionState.intent.name;
    const intentHandler = intentHandlers[intentName];

    if (!intentHandler) {
        return {
            messages: [{
                content: "I'm sorry, I don't know how to handle that request.",
                contentType: 'PlainText'
            }]
        };
    }

    try {
        return await intentHandler(event);
    } catch (error) {
        console.error(`Error handling intent ${intentName}:`, error);
        return {
            messages: [{
                content: "I'm sorry, something went wrong. Please try again later.",
                contentType: 'PlainText'
            }]
        };
    }
};

// backend/lib/lexIntegration.js
const { WebSocketManager } = require('./websocket');
const { LexBotHandler } = require('./lexbot/handler');
const { ChatRepository } = require('./dynamodb');

class LexChatIntegration {
    constructor() {
        this.lexBot = new LexBotHandler();
        this.chatRepo = new ChatRepository();
        this.wsManager = null; // Se inicializa en el handler
    }

    async handleMessage(event, context) {
        const body = JSON.parse(event.body);
        const connectionId = event.requestContext.connectionId;
        const userId = event.requestContext.authorizer.claims.sub;

        // Inicializar WebSocket Manager
        this.wsManager = new WebSocketManager(
            event.requestContext.domainName,
            event.requestContext.stage
        );

        try {
            // Procesar mensaje con Lex
            const botResponse = await this.lexBot.processMessage(userId, body.message);

            // Guardar mensaje del usuario
            await this.chatRepo.saveMessage({
                connectionId,
                userId,
                type: 'USER_MESSAGE',
                content: body.message,
                timestamp: Date.now()
            });

            // Guardar respuesta del bot
            await this.chatRepo.saveMessage({
                connectionId,
                userId: 'BOT',
                type: 'BOT_RESPONSE',
                content: botResponse.content,
                metadata: {
                    intent: botResponse.intent,
                    confidence: botResponse.confidence
                },
                timestamp: Date.now()
            });

            // Enviar respuesta al usuario
            await this.wsManager.sendMessage(connectionId, {
                type: 'BOT_RESPONSE',
                content: botResponse.content,
                timestamp: Date.now()
            });

            return {
                statusCode: 200,
                body: 'Message processed successfully'
            };
        } catch (error) {
            console.error('Error processing message:', error);
            return {
                statusCode: 500,
                body: 'Error processing message'
            };
        }
    }
}

module.exports = LexChatIntegration;

// frontend/src/hooks/useWebSocket.js
import { useEffect, useCallback, useState } from 'react';
import useWebSocket from 'react-use-websocket';

export const useChat = (url) => {
  const [messageHistory, setMessageHistory] = useState([]);
  const [connectionStatus, setConnectionStatus] = useState('disconnected');

  const {
    sendMessage,
    lastMessage,
    readyState,
    getWebSocket
  } = useWebSocket(url, {
    onOpen: () => setConnectionStatus('connected'),
    onClose: () => setConnectionStatus('disconnected'),
    onError: () => setConnectionStatus('error'),
    shouldReconnect: (closeEvent) => true,
    reconnectAttempts: 10,
    reconnectInterval: 3000
  });

  useEffect(() => {
    if (lastMessage) {
      try {
        const data = JSON.parse(lastMessage.data);
        setMessageHistory(prev => [...prev, data]);
      } catch (e) {
        console.error('Error parsing message:', e);
      }
    }
  }, [lastMessage]);

  const send = useCallback((message) => {
    if (readyState === 1) {
      sendMessage(JSON.stringify(message));
      return true;
    }
    return false;
  }, [readyState, sendMessage]);

  const clearHistory = useCallback(() => {
    setMessageHistory([]);
  }, []);

  return {
    send,
    messages: messageHistory,
    status: connectionStatus,
    clearHistory,
    readyState
  };
};

// frontend/src/hooks/useAuth.js
import { useState, useEffect, createContext, useContext } from 'react';
import { Auth } from 'aws-amplify';

const AuthContext = createContext(null);

export const AuthProvider = ({ children }) => {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    checkUser();
  }, []);

  async function checkUser() {
    try {
      const userData = await Auth.currentAuthenticatedUser();
      setUser(userData);
    } catch (error) {
      setUser(null);
    } finally {
      setLoading(false);
    }
  }

  async function signIn(username, password) {
    try {
      const user = await Auth.signIn(username, password);
      setUser(user);
      return user;
    } catch (error) {
      throw error;
    }
  }

  async function signOut() {
    try {
      await Auth.signOut();
      setUser(null);
    } catch (error) {
      throw error;
    }
  }

  const value = {
    user,
    loading,
    signIn,
    signOut
  };

  return (
    <AuthContext.Provider value={value}>
      {!loading && children}
    </AuthContext.Provider>
  );
};

export const useAuth = () => {
  const context = useContext(AuthContext);
  if (!context) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
};