from nIRC.irc import Bot, Context, IRCConnection, Logger
from typing import Optional
import asyncio

BOT_NICK = "nIRC"
COMMAND_PREFIX = "!"
CHANNELS_TO_JOIN = {
    "#chat": None,
    "#logs": None,
}
SERVER = "127.0.0.1"
PORT = 6667
SERVER_PASSWORD: Optional[str] = None

@Bot.command("load")
async def load_cmd(ctx: Context):
    if not ctx.arg:
        await ctx.reply("Usage: !load ")
        return

    cog_name = ctx.arg
    try:
        res= ctx.bot.load_cog(cog_name)
        if res[0]== 0:
            await ctx.reply(f"Cog '{cog_name}' loaded successfully.")
        elif res[0]== 1:
            await ctx.reply(f"Cog '{cog_name}' is already loaded.")
        else:
            await ctx.reply(f"Error loading Cog:")
            for line in str(res[1]).splitlines():
                await ctx.send(line)
    except Exception as e:
        await ctx.reply(f"Error loading cog '{cog_name}': {e}")

@Bot.command("unload")
async def unload_cmd(ctx: Context):
    if not ctx.arg:
        await ctx.reply("Usage: !unload ")
        return

    cog_name = ctx.arg
    try:
        res= ctx.bot.unload_cog(cog_name)
        if res[0]== 0:
            await ctx.reply(f"Cog '{cog_name}' unloaded successfully.")
        elif res[0]== 1:
            await ctx.reply(f"Cog '{cog_name}' is not loaded.")
        else:
            await ctx.reply(f"Error unloading Cog:")
            for line in str(res[1]).splitlines():
                await ctx.send(line)
    except Exception as e:
        await ctx.reply(f"Error unloading cog '{cog_name}': {e}")

@Bot.command("reload")
async def reload_cmd(ctx: Context):
    if not ctx.arg:
        await ctx.reply("Usage: !reload ")
        return

    cog_name = ctx.arg
    try:
        res= ctx.bot.reload_cog(cog_name)
        if res[0]== 0:
            await ctx.reply(f"Cog '{cog_name}' reloaded successfully.")
        elif res[0]== 1:
            await ctx.reply(f"Cog '{cog_name}' is not loaded.")
        else:
            await ctx.reply(f"Error reloading Cog:")
            for line in str(res[1]).splitlines():
                await ctx.send(line)
    except Exception as e:
        await ctx.reply(f"Error reloading cog '{cog_name}': {e}")

@Bot.on_ready()
async def initialization_setup(bot: Bot):
    """
    Runs once after connection and IRC registration is complete (after 376).
    Starts tasks and can perform one-time setup actions.
    """

    if "#chat" in bot.channel_map:
        await bot.conn.send_raw(f"MODE #chat +m") # Set +m (moderated) on #chat as an example one-time setup.

    # You can load cogs on startup here, try using the following:
    # bot.load_cog("cogs.test")


async def run_bot():
    """Main entry point to initialize and run the bot."""

    global logger
    logger= Logger(file_path= "log.txt", min_level= 0)

    irc_connection = IRCConnection(SERVER, PORT, logger)

    bot = Bot(
        prefix=COMMAND_PREFIX,
        conn=irc_connection,
        nick=BOT_NICK,
        username="nirc_bot",
        realname="neko IRC bot framework example client",
        password=SERVER_PASSWORD
    )

    try:
        await bot.start(CHANNELS_TO_JOIN) #type: ignore
    except Exception as e:
        print(f"FATAL BOT ERROR: {e}")

if __name__ == "__main__":
    print("--- Starting Live Asynchronous nIRC Bot Framework Example ---")
    print(f"Connecting as NICK: {BOT_NICK} to {SERVER}:{PORT}")
    print(f"Channels configured: {', '.join(CHANNELS_TO_JOIN.keys())}")

    try:
        asyncio.run(run_bot())
    except KeyboardInterrupt:
        print("\n[BOT] Shutting down gracefully via Ctrl+C.")
    except RuntimeError as e:
        if "cannot run" in str(e):
            print("\n[ERROR] Event loop error. If running in an interactive session, this is normal.")
        else:
            raise

from nIRC.irc import Bot, Context, DCCFile, Member


@Bot.command("hello")
async def hello_from_cog(ctx: Context):
    """A simple command loaded from a cog."""

    await ctx.reply(f"Hello {ctx.author}! This command was loaded from test.py.")

@Bot.task(interval=60.0, max_repeat=5)
async def cog_task(bot_instance: Bot):
    """A recurring task loaded from a cog."""

    current = getattr(cog_task, 'current_repeat', 0)
    total = getattr(cog_task, 'max_repeat', 0)

    bot_instance.logger.info("TASK", f"[COG] Cog task is running! Repeat {current}/{total}")
    for channel in bot_instance.channel_map:
        await bot_instance.send_message(channel, f"Cog task reporting in! (Run {current}/{total})")

@Bot.command("tasker")
async def cog_task_runner(ctx: Context):
    """Runs an nIRC bot task specifically one that requires no args"""

    task_name= ctx.arg
    if not ctx.arg:
        await ctx.reply("Usage: !tasker ")
        return

    try:
        func= ctx.bot.task_registry[task_name]
        ctx.bot.start_task(func)
        await ctx.reply(f"Running task: {task_name}")
    except Exception as e:
        await ctx.reply(f"Failed to run task: {e}")

@Bot.command("rmcmd")
async def cog_rm_cmd(ctx: Context):
    """Removes a command from the runnable commands"""

    if not ctx.arg:
        await ctx.reply("Usage: !rmcmd ")
        return

    removed= False
    cmd_name= ctx.arg
    old_reg= ctx.bot.commands.copy()
    ctx.bot.commands.clear()
    for cmd, func in old_reg.items():
        if not cmd == cmd_name:
            ctx.bot.commands[cmd]= func # Note: this will most likely break on a cog unload due to the main _event_registry remaining intact
        else:
            removed= True

    if removed:
        await ctx.reply(f"Removed command: '{cmd_name}'.")
    else:
        await ctx.reply(f"Commands '{cmd_name}' not found.")

@Bot.command("commands")
async def loaded_commands(ctx: Context):
    """Shows what commands you have loaded"""

    coms= ""
    pcoms= ""
    events= ""
    tasks= ""

    for com in ctx.bot.commands:
        coms+= str(com)+ " "

    for pcom in ctx.bot.prefix_commands:
        pcoms+= str(pcom)+ " "

    for event in ctx.bot.event_handlers:
        events+= str(event)+ f"({len(ctx.bot.event_handlers[event])}) "

    for task in ctx.bot.task_registry:
        tasks+= str(task)+ " "

    await ctx.send("===Registered Events=======================================")
    await ctx.send(f"Commands: {coms}")
    await ctx.send(f"Prefix Commands: {pcoms}")
    await ctx.send(f"Events: {events}")
    await ctx.send(f"Tasks: {tasks}")
    await ctx.send("===========================================================")

@Bot.prefix_command(">")
async def ai_query_command(ctx: Context):
    """
    Fires on any message starting with '>' (e.g., >what is my status).
    This is great for clean, non-standard bot interactions.
    """

    if ctx.arg:
        response = f"AI Service received query from {ctx.author}: '{ctx.arg}'. Processing..."
        await ctx.reply(response)
        await ctx.send(str(ctx.args))
        await ctx.send(str(ctx.full_line))
    else:
        await ctx.reply("Please provide a query after the '>'.")

@Bot.command("calc")
async def calculate_command(ctx: Context):
    """
    Demonstrates using ctx.arg and ctx.args.
    A simplified math evaluator.
    """

    if not ctx.arg:
        await ctx.reply("Usage: !calc  (e.g., 5 + 3 * 2)")
        return

    try:
        # Warning: Using eval() is generally unsafe in production bots.
        # This is for demonstration purposes only.
        result = eval(ctx.arg)
        await ctx.reply(f"Result for '{ctx.arg}': {result}")
    except Exception:
        await ctx.reply(f"Could not calculate the expression: {ctx.arg}")

@Bot.command("mod")
async def mod_command(ctx: Context):
    """
    Handles moderation actions using Member and Channel abstractions.
    Usage: !mod   [reason/value]
    """

    if len(ctx.args) < 2:
        await ctx.reply("Usage: !mod   [value]")
        return

    action = ctx.args[0].lower()
    target_nick_or_mask = ctx.args[1]
    value_or_reason = " ".join(ctx.args[2:]) or "No reason provided."

    if action == "kick":
        member = ctx.get_member(target_nick_or_mask)
        await member.kick(ctx.target, value_or_reason)
        await ctx.reply(f"Attempted to kick {target_nick_or_mask} from {ctx.target}.")

    elif action == "ban":
        member = ctx.get_member(target_nick_or_mask)
        await member.ban(ctx.target, value_or_reason)
        await ctx.reply(f"Attempted to ban and kick {target_nick_or_mask} from {ctx.target}.")

    elif action == "topic" and ctx.target.startswith('#'):
        await ctx.channel_obj.set_topic(value_or_reason)
        await ctx.reply(f"New topic set to: {value_or_reason}")

    elif action == "unban" and ctx.target.startswith('#'):
        await ctx.channel_obj.unban(target_nick_or_mask)
        await ctx.reply(f"Attempted to remove ban mask: {target_nick_or_mask}")

    else:
        await ctx.reply(f"Unknown moderation action: {action}. Use kick, ban, topic, or unban.")

@Bot.command("pmuser")
async def pm_user_command(ctx: Context):
    """Sends a private message to a specified user."""

    if len(ctx.args) < 2:
        await ctx.reply("Usage: !pmuser  ")
        return

    recipient_nick = ctx.args[0]
    message_text = " ".join(ctx.args[1:])

    await ctx.bot.send_message(recipient_nick, f"PM from {ctx.author}: {message_text}")
    await ctx.reply(f"PM sent to {recipient_nick}.")

@Bot.on_message()
async def keyword_responder(ctx: Context):
    """Responds to specific keywords in a channel message."""

    message = ctx.message.lower()
    if message.strip() == ctx.bot.nick.lower():
        await ctx.reply(f"My command prefix is '{ctx.bot.prefix}'.")
        coms= ""
        for com in ctx.bot.commands:
            coms+= ctx.bot.prefix+ str(com)+ " "
        await ctx.send(f"Available commands: {coms}")

@Bot.on_join()
async def greet_joiner(ctx: Context):
    """Sends a friendly greeting when a new user joins."""

    if ctx.author != ctx.bot.nick:
        await ctx.reply(f"Welcome, {ctx.author}! Type {ctx.bot.prefix}commands to get a list of commands and events.")

@Bot.on_raw()
async def raw_logger(ctx: Context):
    """Logs the raw line to the console (for demonstration only, triggers on all lines)."""

    if "ERROR" in ctx.full_line or "NOTICE" in ctx.full_line:
        print(f"[RAW LOG] IMPORTANT LINE: {ctx.full_line}")

@Bot.prefix_command("?")
async def cog_prefix_cmd(ctx: Context):
    """A prefix command loaded from a cog."""

    await ctx.reply(f"Cog prefix command '?' triggered with: {ctx.arg}")

@Bot.on_dcc()
async def get_file(file: DCCFile):
    """DCC handler for receiving files over DCC"""

    file.context.logger.info("USER", f"Accepting file '{file.filename}' from {file.sender}.")
    user = Member(file.context.bot, file.sender)
    await user.send("Thanks for the file, it's *definitely* safe :3")
    await file.start_transfer()