import gradio as gr
import os
import numpy as np
from PIL import Image
from pytube import YouTube
import demoji
import sounddevice
from scipy.io.wavfile import write
from textblob import TextBlob
from faker import Faker
import pandas as pd
from difflib import SequenceMatcher

# Function for Image Mirroring
def mirror_image(input_img):
    if input_img is None:
        return None
    mirrored_img = Image.fromarray(input_img).transpose(Image.FLIP_LEFT_RIGHT)
    return mirrored_img

# Function for YouTube to MP3 Download
def download_youtube_mp3(url, destination="."):
    if not url:
        return "Please enter a valid URL"
    
    try:
        yt = YouTube(url)
        video = yt.streams.filter(only_audio=True).first()
        
        if not destination:
            destination = "."
            
        out_file = video.download(output_path=destination)
        
        # Save the file with .mp3 extension
        base, ext = os.path.splitext(out_file)
        new_file = base + '.mp3'
        os.rename(out_file, new_file)
        
        return f"{yt.title} has been successfully downloaded in .mp3 format at {new_file}"
    except Exception as e:
        return f"Error: {str(e)}"

# Function for Emoji Detection
def detect_emojis(text):
    if not text:
        return "Please enter text containing emojis"
    
    emoji_dict = demoji.findall(text)
    if emoji_dict:
        result = "Emojis found:\n"
        for emoji, desc in emoji_dict.items():
            result += f"{emoji}: {desc}\n"
        return result
    else:
        return "No emojis found in the text"

# Function for Voice Recording
def record_voice(seconds):
    if seconds <= 0:
        return "Please enter a positive number of seconds"
    
    try:
        fs = 44100  # Sample rate
        recording = sounddevice.rec(int(seconds * fs), samplerate=fs, channels=2)
        sounddevice.wait()
        
        output_file = "recording.wav"
        write(output_file, fs, recording)
        
        return f"Recording completed! Saved as {output_file}", output_file
    except Exception as e:
        return f"Error recording: {str(e)}", None

# Function for Spell Correction
def correct_spelling(text):
    if not text:
        return "Please enter text to correct"
    
    words = text.split()
    corrected_words = []
    
    for word in words:
        corrected_words.append(str(TextBlob(word).correct()))
    
    return f"Original: {text}\nCorrected: {' '.join(corrected_words)}"

# Function to Check for Disarium Number
def check_disarium(number):
    try:
        number = int(number)
        if number <= 0:
            return "Please enter a positive integer"
        
        length = len(str(number))
        temp = number
        sum_val = 0
        
        while temp > 0:
            rem = temp % 10
            sum_val += rem ** length
            temp = temp // 10
            length -= 1
            
        if sum_val == number:
            return f"{number} is a Disarium Number"
        else:
            return f"{number} is NOT a Disarium Number"
    except ValueError:
        return "Please enter a valid integer"

# Function to Generate Fake Data
def generate_fake_data(count=1, include_profile=False):
    if count <= 0:
        return "Please enter a positive number"
    
    fake = Faker()
    
    if include_profile:
        data = [fake.profile() for _ in range(count)]
        df = pd.DataFrame(data)
        return df.to_string()
    else:
        result = ""
        for _ in range(count):
            result += f"Name: {fake.name()}\n"
            result += f"Address: {fake.address()}\n"
            result += f"Text: {fake.text()}\n\n"
        return result

# Function to Compare Text Similarity
def compare_texts(text1, text2):
    if not text1 or not text2:
        return "Please enter both texts to compare"
    
    similarity = SequenceMatcher(None, text1, text2).ratio()
    return f"The texts are {similarity * 100:.2f}% similar"

# Create the Gradio interface with tabs
with gr.Blocks(title="MultiToolBox") as app:
    gr.Markdown("# MultiToolBox")
    gr.Markdown("A versatile utility toolkit with multiple functions")
    
    with gr.Tabs():
        # Image Mirroring Tab
        with gr.Tab("Image Mirror"):
            gr.Markdown("### Mirror an Image Horizontally")
            with gr.Row():
                with gr.Column():
                    img_input = gr.Image(label="Upload Image")
                    mirror_btn = gr.Button("Mirror Image")
                with gr.Column():
                    img_output = gr.Image(label="Mirrored Image")
            
            mirror_btn.click(fn=mirror_image, inputs=img_input, outputs=img_output)
            
            gr.Markdown("""
            **How to use:**
            1. Upload an image using the upload button
            2. Click "Mirror Image" to flip it horizontally
            3. The result will appear in the right panel
            """)
        
        # YouTube to MP3 Tab
        with gr.Tab("YouTube to MP3"):
            gr.Markdown("### Download YouTube Videos as MP3")
            yt_url = gr.Textbox(label="YouTube URL")
            yt_destination = gr.Textbox(label="Destination Folder (leave empty for current directory)", placeholder=".")
            yt_download_btn = gr.Button("Download")
            yt_output = gr.Textbox(label="Result")
            
            yt_download_btn.click(fn=download_youtube_mp3, inputs=[yt_url, yt_destination], outputs=yt_output)
            
            gr.Markdown("""
            **How to use:**
            1. Enter a valid YouTube URL (e.g., https://www.youtube.com/watch?v=dQw4w9WgXcQ)
            2. Optionally specify a destination folder
            3. Click "Download" to convert and save as MP3
            
            **Example:** https://www.youtube.com/watch?v=dQw4w9WgXcQ
            """)
        
        # Emoji Detection Tab
        with gr.Tab("Emoji Detector"):
            gr.Markdown("### Detect Emojis in Text")
            emoji_input = gr.Textbox(label="Enter text with emojis")
            emoji_detect_btn = gr.Button("Detect Emojis")
            emoji_output = gr.Textbox(label="Results")
            
            emoji_detect_btn.click(fn=detect_emojis, inputs=emoji_input, outputs=emoji_output)
            
            gr.Markdown("""
            **How to use:**
            1. Enter text containing emojis
            2. Click "Detect Emojis" to identify and describe them
            
            **Example:** "I love reading books 📚❤️🌹"
            """)
        
        # Voice Recorder Tab
        with gr.Tab("Voice Recorder"):
            gr.Markdown("### Record Audio")
            rec_seconds = gr.Number(label="Recording Duration (seconds)", value=5)
            rec_button = gr.Button("Start Recording")
            rec_output = gr.Textbox(label="Recording Status")
            audio_output = gr.Audio(label="Recorded Audio")
            
            rec_button.click(fn=record_voice, inputs=rec_seconds, outputs=[rec_output, audio_output])
            
            gr.Markdown("""
            **How to use:**
            1. Enter the desired recording duration in seconds
            2. Click "Start Recording"
            3. Wait for the recording to complete
            4. Play back the recorded audio using the player
            
            **Example:** Enter 5 for a 5-second recording
            """)
        
        # Spell Correction Tab
        with gr.Tab("Spell Checker"):
            gr.Markdown("### Correct Spelling Errors")
            spell_input = gr.Textbox(label="Enter text with spelling errors")
            spell_btn = gr.Button("Correct Spelling")
            spell_output = gr.Textbox(label="Corrected Text")
            
            spell_btn.click(fn=correct_spelling, inputs=spell_input, outputs=spell_output)
            
            gr.Markdown("""
            **How to use:**
            1. Enter text with spelling mistakes
            2. Click "Correct Spelling" to fix errors
            
            **Example:** "I havv a problm with speling"
            """)
        
        # Disarium Number Tab
        with gr.Tab("Disarium Checker"):
            gr.Markdown("### Check if a Number is a Disarium Number")
            gr.Markdown("""
            A Disarium number is a number where the sum of its digits raised to their respective positions equals the number itself.
            Example: 135 is a Disarium number because 1^1 + 3^2 + 5^3 = 1 + 9 + 125 = 135
            """)
            
            disarium_input = gr.Textbox(label="Enter a number")
            disarium_btn = gr.Button("Check")
            disarium_output = gr.Textbox(label="Result")
            
            disarium_btn.click(fn=check_disarium, inputs=disarium_input, outputs=disarium_output)
            
            gr.Markdown("""
            **How to use:**
            1. Enter a positive integer
            2. Click "Check" to determine if it's a Disarium number
            
            **Examples:**
            - 135 (Disarium number)
            - 89 (Disarium number: 8^1 + 9^2 = 8 + 81 = 89)
            - 175 (Not a Disarium number)
            """)
        
        # Fake Data Generator Tab
        with gr.Tab("Fake Data Generator"):
            gr.Markdown("### Generate Fake Data")
            
            with gr.Row():
                fake_count = gr.Number(label="Number of entries", value=1, min=1, step=1)
                fake_profile = gr.Checkbox(label="Generate detailed profiles")
            
            fake_btn = gr.Button("Generate")
            fake_output = gr.Textbox(label="Generated Data", lines=10)
            
            fake_btn.click(fn=generate_fake_data, inputs=[fake_count, fake_profile], outputs=fake_output)
            
            gr.Markdown("""
            **How to use:**
            1. Enter the number of fake data entries to generate
            2. Choose whether to generate detailed profiles
            3. Click "Generate" to create fake data
            
            **Example:** Generate 5 entries with detailed profiles
            """)
        
        # Text Similarity Tab
        with gr.Tab("Text Similarity"):
            gr.Markdown("### Compare Text Similarity")
            
            text1_input = gr.Textbox(label="First Text")
            text2_input = gr.Textbox(label="Second Text")
            compare_btn = gr.Button("Compare")
            similarity_output = gr.Textbox(label="Similarity Result")
            
            compare_btn.click(fn=compare_texts, inputs=[text1_input, text2_input], outputs=similarity_output)
            
            gr.Markdown("""
            **How to use:**
            1. Enter the first text for comparison
            2. Enter the second text for comparison
            3. Click "Compare" to calculate similarity percentage
            
            **Example:**
            - Text 1: "Hello, how are you today?"
            - Text 2: "Hello, how are you doing today?"
            """)

if __name__ == "__main__":
    app.launch()