import streamlit as st
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# Define the RNN or LSTM Model
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x, h):
        out, h = self.lstm(x, h)
        out = self.fc(out[:, -1, :])
        return out, h

# Text generation function
def generate_text(model, start_str, length, char_to_int, int_to_char, num_layers, hidden_size):
    model.eval()
    input_seq = [char_to_int[c] for c in start_str]
    input_seq = torch.tensor(input_seq, dtype=torch.float32).unsqueeze(0).unsqueeze(-1)
    h = (torch.zeros(num_layers, 1, hidden_size), torch.zeros(num_layers, 1, hidden_size))
    generated_text = start_str

    for _ in range(length):
        output, h = model(input_seq, h)
        _, predicted = torch.max(output, 1)
        predicted_char = int_to_char[predicted.item()]
        generated_text += predicted_char
        input_seq = torch.tensor([char_to_int[predicted_char]], dtype=torch.float32).unsqueeze(0).unsqueeze(-1)

    return generated_text

# Streamlit interface
st.title("RNN/LSTM Text Generation")

# Inputs
text_data = st.text_area("Enter your text data for training:", "To be, or not to be, that is the question:\nWhether 'tis nobler in the mind to suffer\nThe slings and arrows of outrageous fortune,\nOr to take arms against a sea of troubles\nAnd by opposing end them. To die: to sleep;\nNo more; and by a sleep to say we end\nThe heart-ache and the thousand natural shocks\nThat flesh is heir to, 'tis a consummation\nDevoutly to be wish'd. To die, to sleep;\nTo sleep: perchance to dream: ay, there's the rub;\nFor in that sleep of death what dreams may come\nWhen we have shuffled off this mortal coil,\nMust give us pause: there's the respect\nThat makes calamity of so long life;")
start_string = st.text_input("Enter the start string for text generation:")
seq_length = st.number_input("Sequence length:", min_value=10, value=100)
hidden_size = st.number_input("Hidden size:", min_value=50, value=256)
num_layers = st.number_input("Number of layers:", min_value=1, value=2)
learning_rate = st.number_input("Learning rate:", min_value=0.0001, value=0.003, format="%.4f")
num_epochs = st.number_input("Number of epochs:", min_value=1, value=20)
generate_length = st.number_input("Generated text length:", min_value=50, value=500)

if st.button("Train and Generate"):
    # Data Preparation
    text = text_data
    if len(text) <= seq_length:
        st.error("Text data is too short for the given sequence length. Please enter more text data.")
    else:
        chars = sorted(list(set(text)))
        char_to_int = {c: i for i, c in enumerate(chars)}
        int_to_char = {i: c for i, c in enumerate(chars)}

        # Prepare input-output pairs
        dataX = []
        dataY = []
        for i in range(0, len(text) - seq_length):
            seq_in = text[i:i + seq_length]
            seq_out = text[i + seq_length]
            dataX.append([char_to_int[char] for char in seq_in])
            dataY.append(char_to_int[seq_out])

        if len(dataX) == 0:
            st.error("Not enough data to create input-output pairs. Please provide more text data.")
        else:
            X = np.reshape(dataX, (len(dataX), seq_length, 1))
            X = X / float(len(chars))
            Y = np.array(dataY)

            # Convert to PyTorch tensors
            X_tensor = torch.tensor(X, dtype=torch.float32)
            Y_tensor = torch.tensor(Y, dtype=torch.long)

            # Model initialization
            model = LSTMModel(input_size=1, hidden_size=hidden_size, output_size=len(chars), num_layers=num_layers)

            # Loss and optimizer
            criterion = nn.CrossEntropyLoss()
            optimizer = optim.Adam(model.parameters(), lr=learning_rate)

            # Training the model
            for epoch in range(num_epochs):
                h = (torch.zeros(num_layers, 1, hidden_size), torch.zeros(num_layers, 1, hidden_size))
                epoch_loss = 0
                for i in range(len(dataX)):
                    inputs = X_tensor[i].unsqueeze(0)  # Shape: (1, seq_length, 1)
                    targets = Y_tensor[i].unsqueeze(0)  # Shape: (1,)

                    # Forward pass
                    outputs, h = model(inputs, (h[0].detach(), h[1].detach()))
                    loss = criterion(outputs, targets)

                    # Backward pass and optimization
                    optimizer.zero_grad()
                    loss.backward()
                    optimizer.step()

                    epoch_loss += loss.item()

                avg_loss = epoch_loss / len(dataX)
                st.write(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {avg_loss:.4f}')

            # Text generation
            generated_text = generate_text(model, start_string, generate_length, char_to_int, int_to_char, num_layers, hidden_size)
            st.subheader("Generated Text")
            st.write(generated_text)