# This file is part of Senator Sperma
# Licensed under the GPL-3.0 License
# Copyright (C) 2026 Salmonik @ salmonik@tuta.io
# https://codeberg.org/salmonik/senator-sperma

import datetime
import json
import logging
import os
import asyncio
import discord
from discord.ext import commands
from gtts import gTTS
import aiofiles
from cogs.voice import get_voice_manager

logger = logging.getLogger(__name__)

ACTIVITY_FILE = 'temp/voice_activity.json'


def load_activity_data():
    if os.path.exists(ACTIVITY_FILE):
        with open(ACTIVITY_FILE, 'r') as f:
            return json.load(f)
    return {}


def save_activity_data(data):
    with open(ACTIVITY_FILE, 'w') as f:
        json.dump(data, f, indent=4)


def format_duration(seconds):
    hours, remainder = divmod(int(seconds), 3600)
    minutes, seconds = divmod(remainder, 60)
    if hours > 0:
        return f"{hours}h {minutes}m {seconds}s"
    elif minutes > 0:
        return f"{minutes}m {seconds}s"
    return f"{seconds}s"


class VcLogs(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self._voice_manager = None

    def get_voice_manager(self):
        if self._voice_manager is None:
            self._voice_manager = get_voice_manager(self.bot)
        return self._voice_manager

    settings_file = 'settings.json'

    @staticmethod
    async def handle_state_change(member, channel, state_type, is_enabled, current_time, log_channel, activity_suffix=None):
        """Helper method to handle voice state changes"""
        state_messages = {
            'deaf': {
                True: (
                    f"[{current_time}] {member.name} ogłuchnął się na {channel.name}",
                    f"{member.display_name} jest bity przez ojca"
                ),
                False: (
                    f"[{current_time}] {member.name} odgłuchał się na {channel.name}",
                    f"{member.display_name} uciek od ojca"
                )
            },
            'mute': {
                True: (
                    f"[{current_time}] {member.name} wyciszył się na {channel.name}",
                    f"{member.display_name} idzie robić jajecznice"
                ),
                False: (
                    f"[{current_time}] {member.name} odciszył się na {channel.name}",
                    f"{member.display_name} zrobił jajecznice"
                )
            }
        }

        message, tts_text = state_messages[state_type][is_enabled]
        if activity_suffix:
            message = f"{message}\n{activity_suffix}"
        await log_channel.send(message)
        logger.info(f"Voice state change: {message}")
        return tts_text, channel

    async def play_tts(self, channel, text):
        voice_mgr = self.get_voice_manager()
        
        temp_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'temp')
        os.makedirs(temp_dir, exist_ok=True)
        tts_file = os.path.join(temp_dir, f"temp_tts_{os.getpid()}.mp3")
        tts = gTTS(text=text, lang='pl')
        logger.info("saving file")
        tts.save(tts_file)

        if os.path.exists(VcLogs.settings_file):
            async with aiofiles.open(VcLogs.settings_file) as f:
                content = await f.read()
                data = json.loads(content)
                volume = data.get('volume', 1.0)

        voice_client = await voice_mgr.get_voice_client(channel.guild)

        if voice_client is None:
            voice_client = await voice_mgr.join_channel(channel)

        logger.info(f"connected: {voice_client}")
        
        if voice_client and not voice_client.is_playing():
            logger.info("preparing to play audio")
            audio_source = discord.FFmpegPCMAudio(tts_file, options=f'-filter:a "volume={volume}"')
            voice_client.play(audio_source)
            while voice_client.is_playing():
                await asyncio.sleep(0.5)
        if os.path.exists(tts_file):
            os.remove(tts_file)

    @commands.slash_command(
        name="log_volume"
    )
    async def volume(self, ctx: discord.ApplicationContext, volume: int):
        try:
            async with aiofiles.open(VcLogs.settings_file, 'w') as f:
                json.dump({"volume": volume}, f, indent=4)
                await ctx.followup.send(f"Volume has been set to: {volume}")
                logger.info(f"Volume changed to: {volume}")
        except Exception as e:
            await ctx.respond(e, ephemeral=True)
            logger.error(f"Error in volume command: {e}", exc_info=True)

    @commands.Cog.listener()
    async def on_voice_state_update(self, member, before, after):
        log_channel = self.bot.get_channel(1213843195457183885)
        current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        current_ts = datetime.datetime.now().timestamp()
        tts_text = None
        tts_channel = None

        if member.bot:
            return

        user_id = str(member.id)
        activity_data = load_activity_data()

        if before.channel is None and after.channel is not None:
            is_afk = after.self_mute or after.self_deaf
            activity_data[user_id] = {
                'join_time': current_ts,
                'total_active': 0,
                'total_afk': 0,
                'is_afk': is_afk,
                'afk_start': current_ts if is_afk else None,
                'active_start': current_ts if not is_afk else None,
                'channel_name': after.channel.name
            }
            save_activity_data(activity_data)

            message = f"[{current_time}] {member.name} dołączył na {after.channel.name}"
            tts_text = f"{member.display_name} sie zespawnił"
            tts_channel = after.channel
            await log_channel.send(message)
            logger.info(f"User joined voice channel: {message}")

        elif before.channel is not None and after.channel is None:
            if user_id in activity_data:
                data = activity_data[user_id]
                
                if data.get('is_afk') and data.get('afk_start'):
                    afk_duration = current_ts - data['afk_start']
                    data['total_afk'] += afk_duration
                elif data.get('active_start'):
                    active_since_start = current_ts - data['active_start']
                    data['total_active'] += active_since_start
                
                active_str = format_duration(data['total_active'])
                afk_str = format_duration(data['total_afk'])
                
                message = (
                    f"[{current_time}] {member.name} rozłączył się z {before.channel.name}\n"
                    f"   Aktywny: {active_str} | AFK: {afk_str}"
                )
                tts_text = f"{member.display_name} jest chujem"
                tts_channel = before.channel
                await log_channel.send(message)
                logger.info(f"User left voice channel: {message}")
                
                del activity_data[user_id]
                save_activity_data(activity_data)
            else:
                message = f"[{current_time}] {member.name} rozłączył się z {before.channel.name}"
                tts_text = f"{member.display_name} jest chujem"
                tts_channel = before.channel
                await log_channel.send(message)
                logger.info(f"User left voice channel: {message}")

        elif user_id in activity_data:
            data = activity_data[user_id]
            
            if data.get('is_afk') and not (after.self_mute or after.self_deaf):
                afk_duration = current_ts - data['afk_start']
                data['total_afk'] += afk_duration
                data['afk_start'] = None
                data['is_afk'] = False
                data['active_start'] = current_ts
                save_activity_data(activity_data)
            elif not data.get('is_afk') and (after.self_mute or after.self_deaf):
                if data.get('active_start'):
                    active_since_start = current_ts - data['active_start']
                    data['total_active'] += active_since_start
                data['afk_start'] = current_ts
                data['is_afk'] = True
                data['active_start'] = None
                save_activity_data(activity_data)

        if before.self_deaf != after.self_deaf:
            activity_suffix = None
            if user_id in activity_data:
                data = activity_data[user_id]
                if after.self_deaf:
                    active_str = format_duration(data['total_active'])
                    activity_suffix = f"   Aktywny przed AFK: {active_str}"
                else:
                    active_str = format_duration(data['total_active'])
                    afk_str = format_duration(data['total_afk'])
                    activity_suffix = f"   Był AFK: {afk_str} | Łączny aktywny: {active_str}"
            tts_text, tts_channel = await self.handle_state_change(
                member, after.channel, 'deaf', after.self_deaf, current_time, log_channel, activity_suffix
            )
            if tts_text and tts_channel:
                await self.play_tts(tts_channel, tts_text)
            return

        if before.self_mute != after.self_mute:
            activity_suffix = None
            if user_id in activity_data:
                data = activity_data[user_id]
                if after.self_mute:
                    active_str = format_duration(data['total_active'])
                    activity_suffix = f"   Aktywny przed AFK: {active_str}"
                else:
                    active_str = format_duration(data['total_active'])
                    afk_str = format_duration(data['total_afk'])
                    activity_suffix = f"   Był AFK: {afk_str} | Łączny aktywny: {active_str}"
            tts_text, tts_channel = await self.handle_state_change(
                member, after.channel, 'mute', after.self_mute, current_time, log_channel, activity_suffix
            )

        if tts_text and tts_channel:
            await self.play_tts(tts_channel, tts_text)


def setup(bot):
    bot.add_cog(VcLogs(bot))