Further enhance this debate bot, and make it output unique responses. And also add further features:

```
import g4f.client
import tkinter as tk
from tkinter import ttk
import threading

# Configuration
GPT_MODEL = 'gpt-4o'  # Or any other model suitable for debates

# Initialize the G4F client
gpt_client = g4f.client.Client()

# Debate history and guessed characters
debate_history = {}
guessed_characters = set()

# Custom format preset
FORMAT_PRESET = """
system

{{#if system}}{{system}}\n{{/if}}
{{#if wiBefore}}{{wiBefore}}\n{{/if}}
{{#if description}}{{description}}\n{{/if}}
{{#if personality}}{char}'s personality: {{personality}}\n{{/if}}
{{#if scenario}}Scenario: {{scenario}}\n{{/if}}
{{#if wiAfter}}{{wiAfter}}\n{{/if}}
{{#if persona}}{{persona}}\n{{/if}}
{{trim}}
"""

# Debate prompt
DEBATE_PROMPT = """
I'm going to give you an imaginary theoretically abduction prompt of who fights better. You're a smart API that will smartly debate on who fights better (fictional character, ver.) All guesses that aren't fictional characters are wrong and thereby banned, and also apply real-world applications.

["For Example: Goku fights better than Simpson"]

Make sure your arguments are consistent and consider the context of previous debates. You'll also have to only pick ONE fictional character that beats {character}, just like in the game "What beats rock?", but instead you can't pick the character that's already been chosen.

First Debate of the Day: What fights better than {character}?
"""

def generate_debate_prompt(character):
    """Generates a debate prompt using a custom format preset."""
    # Prepare the data for formatting
    format_data = {
        'system': 'You are a debate AI specialized in comparing fictional characters based on their fighting abilities.',
        'description': 'The debate focuses on who fights better among fictional characters. Provide detailed arguments.',
        'personality': 'The debate AI should be assertive and analytical.',
        'scenario': DEBATE_PROMPT.format(character=character),
        'wiBefore': 'Consider the strengths and weaknesses of the characters involved.',
        'wiAfter': 'Summarize the debate and conclude which character fights better. Ensure consistency with previous debates.',
        'persona': f'Debate with a focus on {character}\'s abilities and real-world applications.',
    }

    # Format the prompt based on the format preset
    formatted_prompt = FORMAT_PRESET
    for key, value in format_data.items():
        formatted_prompt = formatted_prompt.replace(f'{{{{{key}}}}}', value)

    return formatted_prompt

def query_debate_ai(character):
    """Queries the debate AI for the best fighting fictional character."""
    prompt = generate_debate_prompt(character)
    response = gpt_client.chat.completions.create(
        model=GPT_MODEL,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=2048
    )
    result = response.choices[0].message.content

    # Store the response in history
    debate_history[character] = result
    return result

def ensure_consistency(character, response):
    """Ensures consistency in the debate responses by checking against history."""
    for opponent, previous_response in debate_history.items():
        if opponent != character:
            if character in previous_response:
                # Check if the new response contradicts previous responses
                if ("loses to" in previous_response and "beats" in response) or \
                   ("beats" in previous_response and "loses to" in response):
                    return (f"Your previous response about {opponent} was inconsistent with the current debate about {character}. "
                            "Please review and adjust your response.")

    return response

def filter_guessable_characters(character):
    """Filters out characters that have already been guessed or debated."""
    if character in guessed_characters:
        return "This character has already been debated. Please choose a different one."

    # Add the new character to guessed characters
    guessed_characters.add(character)
    return None

def on_submit():
    character = entry.get().strip()
    if not character:
        result_text.delete(1.0, tk.END)
        result_text.insert(tk.END, "Please enter a fictional character.")
        return
    
    # Filter out previously guessed characters
    filtered_message = filter_guessable_characters(character)
    if filtered_message:
        result_text.delete(1.0, tk.END)
        result_text.insert(tk.END, filtered_message)
        return

    submit_button.config(state="disabled")
    threading.Thread(target=process_input, args=(character,)).start()

def process_input(character):
    response = query_debate_ai(character)
    consistent_response = ensure_consistency(character, response)
    result_text.delete(1.0, tk.END)
    result_text.insert(tk.END, consistent_response)
    submit_button.config(state="normal")

root = tk.Tk()
root.title("Debate AI Bot")

style = ttk.Style()
style.theme_use("clam")

entry_frame = ttk.Frame(root, padding="10")
entry_frame.pack(fill=tk.BOTH, expand=True)

entry_label = ttk.Label(entry_frame, text="Enter Fictional Character:")
entry_label.grid(row=0, column=0, padx=5, pady=5)

entry = ttk.Entry(entry_frame, width=40)
entry.grid(row=0, column=1, padx=5, pady=5)

submit_button = ttk.Button(entry_frame, text="Submit", command=on_submit)
submit_button.grid(row=1, column=0, columnspan=2, pady=10)

result_frame = ttk.Frame(root, padding="10")
result_frame.pack(fill=tk.BOTH, expand=True)

result_text = tk.Text(result_frame, height=10, width=40, wrap=tk.WORD)
result_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
result_scroll_bar = ttk.Scrollbar(result_frame, orient=tk.VERTICAL, command=result_text.yview)
result_scroll_bar.pack(side=tk.RIGHT, fill=tk.Y)
result_text.config(yscrollcommand=result_scroll_bar.set)

root.mainloop()
```