import torch
import torch.nn as nn
import torch.optim as optim
from gensim.models import Word2Vec
import numpy as np
import random
import MeCab
from collections import Counter
from torch.utils.data import Dataset, DataLoader
import tqdm
from nltk.translate.bleu_score import sentence_bleu 
import numpy as np
import argparse as arg
import nltk
import unicodedata
import re
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence



mecab = MeCab.Tagger("-Owakati")
def unicodeToAscii(s):
    return ''.join(
        c for c in unicodedata.normalize('NFD', s)
        if unicodedata.category(c) != 'Mn'
    )
def normalizeString(s):
    s = unicodeToAscii(s.lower().strip())
    s = re.sub(r"([.!?])", r" \1", s)
    s = re.sub(r"[^a-zA-Z.!?]+", r" ", s)
    return s

def tokenize(sentence, language="en"):
    if language == "en":
        sentence = normalizeString(sentence)
        return sentence.strip().split()
    else:
        return mecab.parse(sentence).strip().split()

def build_vocab(sentences, language="en", min_freq=1):
    counter = Counter()
    for sentence in sentences:
        tokens = tokenize(sentence, language=language)
        counter.update(tokens)
    vocab = [word for word, freq in counter.items() if freq >= min_freq]
    vocab = ['<pad>', '<sos>', '<eos>', '<unk>'] + sorted(vocab)
    word2idx = {word: idx for idx, word in enumerate(vocab)}
    idx2word = {idx: word for word, idx in word2idx.items()}
    return vocab, word2idx, idx2word

def read_data(filepath):
    english_sentences = []
    japanese_sentences = []
    with open(filepath, "r", encoding="utf-8") as f:
        for line in f:
            jp_sentence, en_sentence = line.strip().split("\t")
            english_sentences.append(en_sentence)
            japanese_sentences.append(jp_sentence)
    return english_sentences, japanese_sentences

train_dataset_path="./data/train.txt" 
valid_dataset_path="./data/valid.txt"
test_dataset_path="./data/test.txt"

train_en_sentences, train_jp_sentences = read_data(train_dataset_path)
valid_en_sentences, valid_jp_sentences = read_data(valid_dataset_path)
test_en_sentences, test_jp_sentences = read_data(test_dataset_path)

en_vocab, en_word2idx, en_idx2word = build_vocab(train_en_sentences + valid_en_sentences + test_en_sentences, language="en")
jp_vocab, jp_word2idx, jp_idx2word = build_vocab(train_jp_sentences + valid_jp_sentences + test_jp_sentences, language="jp")

def collate_fn(batch):
    # 解压批次中的源语言和目标语言序列
    src_seqs, trg_seqs = zip(*batch)

    # 将列表转换为张量
    src_seqs = [torch.tensor(seq, dtype=torch.long) for seq in src_seqs]
    trg_seqs = [torch.tensor(seq, dtype=torch.long) for seq in trg_seqs]

    # 获取每个序列的长度
    src_lengths = torch.tensor([len(seq) for seq in src_seqs], dtype=torch.long)
    trg_lengths = torch.tensor([len(seq) for seq in trg_seqs], dtype=torch.long)

    # 对序列进行填充
    src_padded = pad_sequence(src_seqs, batch_first=True, padding_value=jp_word2idx['<pad>'])
    trg_padded = pad_sequence(trg_seqs, batch_first=True, padding_value=en_word2idx['<pad>'])

    return src_padded, trg_padded, src_lengths, trg_lengths
def sentence_to_indices(sentence, word2idx, language="en"):
    tokens = tokenize(sentence, language)
    indices = [word2idx.get(token, word2idx['<unk>']) for token in tokens]
    return indices


class TranslationDataset(Dataset):
    def __init__(self, src_sentences, trg_sentences, src_word2idx, trg_word2idx, max_len=50):
        self.src_sentences = src_sentences
        self.trg_sentences = trg_sentences
        self.src_word2idx = src_word2idx
        self.trg_word2idx = trg_word2idx
        self.max_len = max_len

    def __len__(self):
        return len(self.src_sentences)

    def __getitem__(self, idx):
        src_sentence = self.src_sentences[idx]
        trg_sentence = self.trg_sentences[idx]

        src_indices = [self.src_word2idx['<sos>']] + sentence_to_indices(src_sentence, self.src_word2idx, language="jp") + [self.src_word2idx['<eos>']]
        trg_indices = [self.trg_word2idx['<sos>']] + sentence_to_indices(trg_sentence, self.trg_word2idx, language="en") + [self.trg_word2idx['<eos>']]

        src_indices = src_indices[:self.max_len]
        trg_indices = trg_indices[:self.max_len]

        src_len = len(src_indices)
        trg_len = len(trg_indices)

        src_padded = src_indices + [self.src_word2idx['<pad>']] * (self.max_len - src_len)
        trg_padded = trg_indices + [self.trg_word2idx['<pad>']] * (self.max_len - trg_len)

        return torch.tensor(src_padded), torch.tensor(trg_padded)

def load_pretrained_embedding(word2vec_model, vocab, embedding_dim):
    embedding_matrix = np.zeros((len(vocab), embedding_dim))
    for i, word in enumerate(vocab):
        if word in word2vec_model.wv:
            embedding_matrix[i] = word2vec_model.wv[word]
        else:
            embedding_matrix[i] = np.random.normal(size=(embedding_dim,))
    return torch.FloatTensor(embedding_matrix)

# def init_weights(m):
#     if isinstance(m, nn.Embedding):
#         pass 
#     elif isinstance(m, nn.Linear):
#         nn.init.xavier_uniform_(m.weight)
#         if m.bias is not None:
#             nn.init.constant_(m.bias, 0)
#     elif isinstance(m, nn.LSTM):
#         for name, param in m.named_parameters():
#             if 'weight_ih' in name:
#                 nn.init.xavier_uniform_(param.data)
#             elif 'weight_hh' in name:
#                 nn.init.xavier_uniform_(param.data)
#             elif 'bias' in name:
#                 nn.init.constant_(param.data, 0)
#     elif isinstance(m, nn.Parameter):
#         nn.init.xavier_uniform_(m.data)
        
class Attention(nn.Module):
    def __init__(self, hidden_dim):
        super(Attention, self).__init__()
        # 定义两个线性层来处理 hidden 和 encoder_outputs
        self.attn = nn.Linear(hidden_dim * 3, hidden_dim)
        self.v = nn.Linear(hidden_dim, 1, bias=False)
        
        # 初始化参数
        # nn.init.xavier_uniform_(self.attn_hidden.weight)
        # nn.init.constant_(self.attn_hidden.bias, 0)
        # nn.init.xavier_uniform_(self.attn_encoder.weight)
        # nn.init.constant_(self.attn_encoder.bias, 0)
        # nn.init.uniform_(self.v.data, a=-0.1, b=0.1)
        
    def forward(self, hidden, encoder_outputs,mask):
        # hidden: [1,batch_size, hidden_dim]
        # encoder_outputs: [batch_size, seq_len, hidden_dim]
        # import pdb;pdb.set_trace()
        batch_size, seq_len, hidden_dim = encoder_outputs.size()
        
        hidden = hidden.permute(1, 0, 2).repeat(1, seq_len, 1)  # [batch_size, 1, hidden_dim]
        
        energy = torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim=2)))  # [batch_size, seq_len, hidden_dim]
        
        attention = self.v(energy).squeeze(2)
        
        attention = attention.masked_fill(mask == 0, -1e15)
        
        attention_weights = torch.softmax(attention, dim=1)  # [batch_size, seq_len]
        # import pdb;pdb.set_trace()
        return attention_weights
class Encoder(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim,  pretrained_embeddings=None, dropout_rate=0.2):
        super(Encoder, self).__init__()
        self.embedding = nn.Embedding.from_pretrained(pretrained_embeddings)

        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True, bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, hidden_dim)
        # self.dropout = nn.Dropout(dropout_rate)
        # self._init_weights()
        
    # def _init_weights(self):
    #     for name, param in self.lstm.named_parameters():
    #         if 'weight_ih' in name:
    #             nn.init.xavier_uniform_(param.data)
    #         elif 'weight_hh' in name:
    #             nn.init.xavier_uniform_(param.data)
    #         elif 'bias' in name:
    #             nn.init.constant_(param.data, 0)
                
    def forward(self, x,seq_length):
        embedded = self.embedding(x)
        emb_tensor=nn.utils.rnn.pack_padded_sequence(embedded,torch.tensor(seq_length, dtype=torch.int32),batch_first=True,enforce_sorted=False)
        lstm_outputs, (hidden, cell) = self.lstm(emb_tensor)
        # import pdb;pdb.set_trace()
        outputs, _ = nn.utils.rnn.pad_packed_sequence(lstm_outputs, batch_first=True)
        # import pdb;pdb.set_trace()
        # outputs = self.dropout(outputs)
        hidden = torch.tanh(self.fc(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)))
        return outputs, hidden.unsqueeze(0), cell

class Decoder(nn.Module):
    def __init__(self, output_dim, embedding_dim, hidden_dim,  attention, pretrained_embeddings=None,dropout_rate=0.2):
        super(Decoder, self).__init__()
        self.output_dim = output_dim
        self.embedding = nn.Embedding.from_pretrained(pretrained_embeddings)
        self.lstm = nn.LSTM(embedding_dim + hidden_dim * 2, hidden_dim, batch_first=True)
        # self.dropout = nn.Dropout(dropout_rate)
        self.attention = attention
        self.fc = nn.Linear(hidden_dim + hidden_dim * 2 + embedding_dim, output_dim)
    #     self._init_weights()

    # def _init_weights(self):
    #     for name, param in self.lstm.named_parameters():
    #         if 'weight_ih' in name:
    #             nn.init.xavier_uniform_(param.data)
    #         elif 'weight_hh' in name:
    #             nn.init.xavier_uniform_(param.data)
    #         elif 'bias' in name:
    #             nn.init.constant_(param.data, 0)
    #     nn.init.xavier_uniform_(self.fc.weight)
    #     nn.init.constant_(self.fc.bias, 0)

    def forward(self, input_step, last_hidden, last_cell, encoder_outputs,mask):
        # import pdb;pdb.set_trace()
        input_step =input_step.unsqueeze(1)
        embedded = self.embedding(input_step)
        attn_weights = self.attention(last_hidden, encoder_outputs,mask)
        attn_weights=attn_weights.unsqueeze(1)
        context = torch.bmm(attn_weights, encoder_outputs)
        lstm_input = torch.cat((embedded, context), dim=2)
        output, (hidden, cell) = self.lstm(lstm_input, (last_hidden,torch.zeros_like(last_hidden)))
        output = output.squeeze(1)
        embedded = embedded.squeeze(1)
        context= context.squeeze(1)
        output = self.fc(torch.cat((output, context, embedded), dim=1))
        # output = self.dropout(output)
        return output, hidden, cell

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder, device):
        super(Seq2Seq, self).__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.device = device
    
    def create_mask(self, src):
        mask = (src != jp_word2idx['<pad>'])
        return mask

    def forward(self, src,src_lengths, trg, teacher_forcing_ratio=0.5):
        batch_size = trg.size(0)
        max_len = trg.size(1)
        # max_len=max(trg.size(1),50)
        trg_vocab_size = self.decoder.output_dim
        outputs = torch.zeros(batch_size, max_len, trg_vocab_size).to(self.device)

        encoder_outputs, hidden, cell = self.encoder(src,src_lengths)
        # hidden = hidden[:self.decoder.lstm.num_layers]
        # cell = cell[:self.decoder.lstm.num_layers]
        input = trg[:, 0]
        mask = self.create_mask(src)
        for t in range(1, max_len):
            output, hidden, cell = self.decoder(input, hidden, cell, encoder_outputs, mask)
            outputs[:, t, :] = output
            top1 = output.argmax(1)
            teacher_force = random.random() < teacher_forcing_ratio
            input = trg[:, t] if teacher_force else top1

        return outputs

def train_model(model, dataloader, optimizer, criterion, device, epochs=10, 
                valid_dataloader=None, patience=2, scheduler=None):
    best_valid_loss = float('inf')
    epochs_no_improve = 0
    model.train()
    for epoch in range(epochs):
        
        epoch_loss = 0
        with tqdm.tqdm(dataloader, unit="batch") as tepoch:
            tepoch.set_description(f"Epoch {epoch+1}/{epochs}")
            for src, trg,src_lengths, _ in tepoch:
                src = src.to(device)
                trg = trg.to(device)
                optimizer.zero_grad()
                output = model(src,src_lengths, trg)
                output_dim = output.shape[-1]
                output = output[:, 1:].reshape(-1, output_dim)
                trg = trg[:, 1:].reshape(-1)
                loss = criterion(output, trg)
                loss.backward()
                optimizer.step()
                epoch_loss += loss.item()
                tepoch.set_postfix(loss=loss.item())
        
        avg_epoch_loss = epoch_loss / len(dataloader)
        
        if valid_dataloader is not None:
            model.eval()
            valid_loss = 0
            with torch.no_grad():
                for src, trg,src_lengths, _ in valid_dataloader:
                    src = src.to(device)
                    trg = trg.to(device)
                    output = model(src, src_lengths, trg,teacher_forcing_ratio=0)
                    output_dim = output.shape[-1]
                    output = output[:, 1:].reshape(-1, output_dim)
                    trg = trg[:, 1:].reshape(-1)
                    loss = criterion(output, trg)
                    valid_loss += loss.item()
            avg_valid_loss = valid_loss / len(valid_dataloader)
            print(f"Epoch {epoch+1}/{epochs}, Training Loss: {avg_epoch_loss:.4f}, Validation Loss: {avg_valid_loss:.4f}")
            
            if scheduler is not None:
                scheduler.step(avg_valid_loss)
            
            if avg_valid_loss < best_valid_loss:
                best_valid_loss = avg_valid_loss
                epochs_no_improve = 0
                torch.save(model.state_dict(), 'best_model.pt')
            else:
                epochs_no_improve += 1
                if epochs_no_improve >= patience:
                    print("验证损失未改善，提前停止训练。")
                    break
            model.train()
        else:
            print(f"Epoch {epoch+1}/{epochs}, Training Loss: {avg_epoch_loss:.4f}")
            if scheduler is not None:
                scheduler.step()
        
def save_model(model, optimizer, epoch, path="seq2seq_model.pth"):
    torch.save({
        'epoch': epoch,
        'model_state_dict': model.state_dict(),
        'optimizer_state_dict': optimizer.state_dict(),
    }, path)


def load_model(model, path="seq2seq_model.pth", device='cpu'):
    checkpoint = torch.load(path, map_location=device)
    model.load_state_dict(checkpoint['model_state_dict'])
    print(f"Model loaded from {path}, last trained for {checkpoint['epoch']} epochs")
    return model

def translate_sentence(model, sentence, jp_word2idx, en_word2idx, en_idx2word, device, max_len=50):
    model.eval()
    with torch.no_grad():
        tokens = tokenize(sentence, language="jp")
        indices = [jp_word2idx.get(token, jp_word2idx['<unk>']) for token in tokens]
        indices = [jp_word2idx['<sos>']] + indices + [jp_word2idx['<eos>']]
        src_tensor = torch.LongTensor(indices).unsqueeze(0).to(device)
        src_length=torch.tensor([len(indices)], dtype=torch.int32)
        encoder_outputs, hidden, cell = model.encoder(src_tensor,src_length)

        input = torch.LongTensor([en_word2idx['<sos>']]).to(device)
        translated_sentence = []
        mask = model.create_mask(src_tensor)
        for _ in range(max_len):
            output, hidden, cell = model.decoder(input, hidden, cell, encoder_outputs,mask )
            top1 = output.argmax(1)
            token = top1.item()
            if token == en_word2idx['<eos>']:
                break
            translated_sentence.append(en_idx2word[token])
            input = top1
    return translated_sentence

def translate_sentence_sample(model, sentence, jp_word2idx, en_word2idx, en_idx2word, device, max_len=50, temperature=0.5):
    model.eval()
    with torch.no_grad():
        tokens = tokenize(sentence, language="jp")
        indices = [jp_word2idx.get(token, jp_word2idx['<unk>']) for token in tokens]
        indices = [jp_word2idx['<sos>']] + indices + [jp_word2idx['<eos>']]
        src_tensor = torch.LongTensor(indices).unsqueeze(0).to(device)
        src_length=torch.tensor([len(indices)], dtype=torch.int32)
        encoder_outputs, hidden, cell = model.encoder(src_tensor,src_length)
        mask = model.create_mask(src_tensor)
        input = torch.LongTensor([en_word2idx['<sos>']]).to(device)
        translated_sentence = []

        for _ in range(max_len):
            output, hidden, cell = model.decoder(input, hidden, cell, encoder_outputs,mask)
            
            output = F.softmax(output / temperature, dim=1)
            
            top1 = torch.multinomial(output, 1).squeeze()

            if len(top1.shape) == 0:
                top1 = top1.unsqueeze(0)

            token = top1.item()
            if token == en_word2idx['<eos>']:
                break
            translated_sentence.append(en_idx2word[token])
            # import pdb;pdb.set_trace()
            input = top1

    return translated_sentence

def calculate_bleu(model, dataset, jp_word2idx, jp_idx2word, en_word2idx, en_idx2word, device):
    bleu_scores = []
    model.eval()
    with torch.no_grad():
        for i in range(len(dataset)):
            src, trg = dataset[i]
            src_sentence = src.cpu().numpy()
            trg_sentence = trg.cpu().numpy()
            
            src_tokens = [jp_idx2word[idx] for idx in src_sentence if idx != jp_word2idx['<pad>'] and idx != jp_word2idx['<sos>'] and idx != jp_word2idx['<eos>']]
            trg_tokens = [en_idx2word[idx] for idx in trg_sentence if idx != en_word2idx['<pad>'] and idx != en_word2idx['<sos>'] and idx != en_word2idx['<eos>']]

            translated_tokens = translate_sentence(model, ' '.join(src_tokens), jp_word2idx, en_word2idx, en_idx2word, device)
            reference = [trg_tokens]
            candidate = translated_tokens
            bleu_score = sentence_bleu(reference, candidate)
            bleu_scores.append(bleu_score)
    average_bleu = np.mean(bleu_scores)
    print(f"Average BLEU score: {average_bleu:.4f}")
    return average_bleu

def calculate_perplexity(model, dataloader, criterion, device):
    total_loss = 0
    total_tokens = 0
    model.eval()
    with torch.no_grad():
        with tqdm.tqdm(dataloader, unit="batch") as tepoch:
            for src, trg,src_lengths, _ in dataloader:
                src = src.to(device)
                trg = trg.to(device)
                output = model(src,src_lengths, trg)  # close teacher forcing
                output_dim = output.shape[-1]
                output = output[:, 1:].reshape(-1, output_dim)
                trg = trg[:, 1:].reshape(-1)
                loss = criterion(output, trg)
                total_loss += loss.item() * trg.size(0)
                total_tokens += trg.size(0)
                tepoch.update(1)
    perplexity = np.exp(total_loss / total_tokens)
    print(f"Perplexity: {perplexity:.4f}")
    return perplexity




def main():
    parser = arg.ArgumentParser()
    parser.add_argument("--mode", type=str, default="train")
    parser.add_argument("--model_path", type=str, default=None )
    parser.add_argument("--batch_size", type=int, default=196)
    parser.add_argument("--epochs", type=int, default=15)
    parser.add_argument("--embedding_dim", type=int, default=100)
    parser.add_argument("--hidden_dim", type=int, default=600)
    parser.add_argument("--encoder_num_layers", type=int, default=1)
    parser.add_argument("--decoder_num_layers", type=int, default=1)
    parser.add_argument("--save_path", type=str, default="seq2seq_model.pth")
    args = parser.parse_args()
    mode=args.mode
    model_path=args.model_path
    EMBEDDING_DIM =args.embedding_dim
    HIDDEN_DIM=args.hidden_dim
    ENCODER_NUM_LAYERS=args.encoder_num_layers
    DECODER_NUM_LAYERS=args.decoder_num_layers
    BATCH_SIZE=args.batch_size
    EPOCHS=args.epochs
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"Using device: {device}")

    jp_model = Word2Vec.load("./data/word2vec_jp.model")
    en_model = Word2Vec.load("./data/word2vec_en.model")
    jp_embeddings = load_pretrained_embedding(jp_model, jp_vocab, EMBEDDING_DIM)
    en_embeddings = load_pretrained_embedding(en_model, en_vocab, EMBEDDING_DIM)

    train_dataset = TranslationDataset(train_jp_sentences, train_en_sentences, jp_word2idx, en_word2idx)
    train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True,collate_fn=collate_fn)

    valid_dataset = TranslationDataset(valid_jp_sentences, valid_en_sentences, jp_word2idx, en_word2idx)
    valid_dataloader = DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=False,collate_fn=collate_fn)
    
    test_dataset = TranslationDataset(test_jp_sentences, test_en_sentences, jp_word2idx, en_word2idx)
    test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False,collate_fn=collate_fn)
    
   
            
    criterion = nn.CrossEntropyLoss(ignore_index=en_word2idx['<pad>'])
    encoder = Encoder(vocab_size=len(jp_vocab), embedding_dim=EMBEDDING_DIM, hidden_dim=HIDDEN_DIM, pretrained_embeddings=jp_embeddings)
    attention = Attention(hidden_dim=HIDDEN_DIM)
    decoder = Decoder(output_dim=len(en_vocab), embedding_dim=EMBEDDING_DIM, hidden_dim=HIDDEN_DIM,  attention=attention, pretrained_embeddings=en_embeddings)
    model = Seq2Seq(encoder, decoder, device).to(device)
    if mode == "train":
        print("start training")
        
        if model_path != "":
            model = load_model(model, model_path, device)
        optimizer = optim.Adam(model.parameters(), lr=1e-3)  
        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=1, verbose=True)

        train_model(model, train_dataloader, optimizer, criterion, device, epochs=EPOCHS, valid_dataloader=valid_dataloader,scheduler=scheduler)
        
        save_model(model, optimizer, EPOCHS, path=args.save_path)
    
    if mode == "eval":
        nltk.download('punkt')
        print("Evaluating model on test set...")
        if model_path is not None:
            model = load_model(model, model_path, device)
        model.eval()
        calculate_bleu(model, train_dataset, jp_word2idx, jp_idx2word, en_word2idx, en_idx2word, device)
        calculate_perplexity(model, test_dataloader, criterion, device)
    
    if mode== "translate":
        if model_path is not None:
            model = load_model(model, model_path, device)
        else:
            print("Please provide a model path to load from.")
            return
        model.eval()
        while True:
            sentence = input("Enter a Japanese sentence (or 'quit' to exit): ").strip()
            if sentence.lower() == 'quit':
                break
            translated_sentence = translate_sentence_sample(model, sentence, jp_word2idx, en_word2idx, en_idx2word, device)
            print(f"Translation: {' '.join(translated_sentence)}")
if __name__ == "__main__":
    main()