import streamlit as st
import streamlit.components.v1 as components
import os
import random
import time
from PIL import Image
import json
from datetime import datetime
from pathlib import Path
import base64
from io import BytesIO

# Initialize session state variables
if 'game_state' not in st.session_state:
    st.session_state.game_state = {
        'players': {},
        'chat_messages': [],
        'tile_map': [],
        'current_player': None
    }

if 'player_name' not in st.session_state:
    st.session_state.player_name = None

if 'last_refresh' not in st.session_state:
    st.session_state.last_refresh = time.time()

if 'start_time' not in st.session_state:
    st.session_state.start_time = None

if 'play_duration' not in st.session_state:
    st.session_state.play_duration = 0

# Utility functions
def load_tiles_and_text():
    """Load tile images and their corresponding markdown text from the root directory"""
    tiles = {}
    for file in os.listdir('.'):
        if file.endswith(('.png', '.jpg', '.jpeg')):
            tile_name = os.path.splitext(file)[0]
            # Load image
            img = Image.open(file)
            # Convert image to base64 for HTML embedding
            buffered = BytesIO()
            img.save(buffered, format="PNG")
            img_str = base64.b64encode(buffered.getvalue()).decode()
            
            # Check for corresponding markdown file
            md_file = f"{tile_name}.md"
            overlay_text = ""
            if os.path.exists(md_file):
                with open(md_file, 'r') as f:
                    overlay_text = f.read().strip()
            
            tiles[tile_name] = {
                'image': img_str,
                'text': overlay_text
            }
    return tiles

def generate_map(width=20, height=15):
    """Generate a random tile map"""
    tile_types = ['grass', 'water', 'rock']
    return [[random.choice(tile_types) for _ in range(width)] for _ in range(height)]

def create_tile_html(tile_data, size=60):
    """Create HTML for a single tile with text overlay"""
    return f"""
        <div style="position: relative; width: {size}px; height: {size}px; display: inline-block;">
            <img src="data:image/png;base64,{tile_data['image']}" 
                 style="width: {size}px; height: {size}px; object-fit: cover;">
            <div style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; 
                        background-color: rgba(255, 255, 255, 0.7); 
                        display: flex; align-items: center; justify-content: center;
                        text-align: center; font-size: 10px; padding: 2px;
                        opacity: 0.8; pointer-events: none;">
                {tile_data['text']}
            </div>
        </div>
    """

def create_game_board_html(tile_map, tiles, players):
    """Create HTML for the entire game board"""
    board_html = """
    <style>
        .game-board { line-height: 0; }
        .player-marker {
            position: absolute;
            width: 10px;
            height: 10px;
            background-color: red;
            border-radius: 50%;
            z-index: 2;
        }
    </style>
    <div class="game-board">
    """
    
    for y, row in enumerate(tile_map):
        for x, tile_type in enumerate(row):
            if tile_type in tiles:
                board_html += create_tile_html(tiles[tile_type])
        board_html += "<br>"
    
    # Add player markers
    for player_name, player_data in players.items():
        pos_x = player_data['position']['x'] * 60 + 25
        pos_y = player_data['position']['y'] * 60 + 25
        board_html += f"""
            <div class="player-marker" style="left: {pos_x}px; top: {pos_y}px;"
                 title="{player_name}"></div>
        """
    
    board_html += "</div>"
    return board_html

def save_game_state():
    """Save the current game state to a file"""
    state_file = Path("game_state.json")
    state_to_save = {
        'players': st.session_state.game_state['players'],
        'chat_messages': st.session_state.game_state['chat_messages'],
        'tile_map': st.session_state.game_state['tile_map']
    }
    with open(state_file, 'w') as f:
        json.dump(state_to_save, f)

def load_game_state():
    """Load the game state from file"""
    state_file = Path("game_state.json")
    if state_file.exists():
        with open(state_file, 'r') as f:
            loaded_state = json.load(f)
            st.session_state.game_state.update(loaded_state)

def add_chat_message(player_name, message):
    """Add a message to the chat history"""
    timestamp = datetime.now().strftime("%H:%M:%S")
    st.session_state.game_state['chat_messages'].append({
        'player': player_name,
        'message': message,
        'timestamp': timestamp
    })
    save_game_state()

def format_duration(seconds):
    """Format duration in seconds to HH:MM:SS"""
    hours = seconds // 3600
    minutes = (seconds % 3600) // 60
    seconds = seconds % 60
    return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"

def check_auto_refresh():
    """Check if it's time to refresh the page"""
    current_time = time.time()
    if current_time - st.session_state.last_refresh >= 5:
        st.session_state.last_refresh = current_time
        st.rerun()

def update_play_duration():
    """Update the player's total play duration"""
    if st.session_state.start_time is not None:
        current_time = time.time()
        st.session_state.play_duration = int(current_time - st.session_state.start_time)

# Main game UI
def main():
    st.title("Multiplayer Tile Game")
    
    if st.session_state.player_name is None:
        with st.form("join_game"):
            player_name = st.text_input("Enter your name:")
            submitted = st.form_submit_button("Join Game")
            if submitted and player_name:
                st.session_state.player_name = player_name
                st.session_state.start_time = time.time()
                st.session_state.play_duration = 0
                st.session_state.game_state['players'][player_name] = {
                    'position': {'x': 0, 'y': 0},
                    'last_active': time.time(),
                    'score': 0
                }
                st.rerun()
    
    else:
        update_play_duration()
        st.sidebar.metric("Play Time", format_duration(st.session_state.play_duration))
        
        col1, col2 = st.columns([2, 1])
        
        with col1:
            st.subheader("Game Map")
            if not st.session_state.game_state['tile_map']:
                st.session_state.game_state['tile_map'] = generate_map()
            
            tiles = load_tiles_and_text()
            if tiles:
                # Generate and display the game board
                board_html = create_game_board_html(
                    st.session_state.game_state['tile_map'],
                    tiles,
                    st.session_state.game_state['players']
                )
                components.html(board_html, height=600)
                
                # Movement controls
                if st.session_state.player_name:
                    player = st.session_state.game_state['players'][st.session_state.player_name]
                    
                    cols = st.columns(4)
                    if cols[0].button("←"):
                        player['position']['x'] = max(0, player['position']['x'] - 1)
                    if cols[1].button("↑"):
                        player['position']['y'] = max(0, player['position']['y'] - 1)
                    if cols[2].button("↓"):
                        player['position']['y'] = min(14, player['position']['y'] + 1)
                    if cols[3].button("→"):
                        player['position']['x'] = min(19, player['position']['x'] + 1)
                
                st.write(f"Position: ({player['position']['x']}, {player['position']['y']})")
            else:
                st.warning("No image files found. Please add .png files and optional .md files with matching names.")
        
        with col2:
            st.subheader("Chat Room")
            chat_container = st.container()
            with chat_container:
                for message in st.session_state.game_state['chat_messages'][-50:]:
                    st.text(f"[{message['timestamp']}] {message['player']}: {message['message']}")
            
            with st.form("chat_form", clear_on_submit=True):
                message = st.text_input("Message:")
                if st.form_submit_button("Send") and message:
                    add_chat_message(st.session_state.player_name, message)
                    st.rerun()
        
        if st.button("Leave Game"):
            if st.session_state.player_name in st.session_state.game_state['players']:
                del st.session_state.game_state['players'][st.session_state.player_name]
            st.session_state.player_name = None
            st.session_state.start_time = None
            st.session_state.play_duration = 0
            save_game_state()
            st.rerun()
        
        check_auto_refresh()

if __name__ == "__main__":
    load_game_state()
    main()