import gradio as gr
import pandas as pd
from transformers import BertForSequenceClassification, Trainer, TrainingArguments, BertTokenizer
from datasets import Dataset
from huggingface_hub import HfApi

class CSVTrainer:
    def __init__(self):
        self.csv_files = []
        self.model_dir = "./Personal"
        self.repo_id = "luohoa97/PersonalBot-o"

    def upload_and_train(self, csv_files):
        if not csv_files:
            return "Please upload at least one CSV file."

        dataframes = [pd.read_csv(file.name) for file in csv_files]
        combined_df = pd.concat(dataframes, ignore_index=True)
        
        combined_df['text'] = combined_df.apply(lambda row: f"{row['Event']} in {row['Location']} on {row['Date']}, {row['Time']}", axis=1)
        combined_df['labels'] = pd.factorize(combined_df['Category'])[0]
        
        dataset = Dataset.from_pandas(combined_df[['text', 'labels']])
        tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

        def tokenize_function(examples):
            return tokenizer(examples['text'], padding='max_length', truncation=True)

        tokenized_datasets = dataset.map(tokenize_function, batched=True)
        tokenized_datasets.set_format("torch", columns=['input_ids', 'attention_mask', 'labels'])

        model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=len(combined_df['labels'].unique()))

        training_args = TrainingArguments(
            output_dir='./results',
            num_train_epochs=3,
            per_device_train_batch_size=16,
            per_device_eval_batch_size=64,
            warmup_steps=500,
            weight_decay=0.01,
            logging_dir='./logs',
            logging_steps=10,
            evaluation_strategy="epoch",
            save_strategy="epoch"
        )

        trainer = Trainer(
            model=model,
            args=training_args,
            train_dataset=tokenized_datasets,
            eval_dataset=tokenized_datasets
        )

        trainer.train()
        model.save_pretrained(self.model_dir)
        self.upload_to_huggingface()

        return "Model uploaded to Hugging Face successfully!"

    def upload_to_huggingface(self):
        api = HfApi()
        try:
            api.create_repo(repo_id=self.repo_id)
        except Exception as e:
            print(f"Repo creation failed: {e}")
        model = BertForSequenceClassification.from_pretrained(self.model_dir)
        model.push_to_hub(self.repo_id)

trainer = CSVTrainer()

def gradio_interface(file):
    return trainer.upload_and_train(file)

iface = gr.Interface(
    fn=gradio_interface,
    inputs=gr.inputs.File(label="Upload CSV Files", type="file", multiple=True),
    outputs="text",
    title="CSV Trainer",
    description="Upload CSV files for training a BERT model."
)

iface.launch()