import json
import random

from rich.console import Console
from rich.table import Table
from rich.prompt import Prompt
from rich import box

crafting_recipes = {
    'recipe1': {'input': {'A': 4, 'B': 4}, 'output': {'C': 10}, 'turns': 3},
    'recipe2': {'input': {'A': 1, 'B': 1}, 'output': {'C': 2}, 'turns': 2}
}


def load_json(filename):
    try:
        with open(filename) as file:
            return json.load(file)
    except FileNotFoundError:
        print(f"Error: The file {filename} was not found.")
        exit(1)


class Market:
    def __init__(self):
        self.current_turn = 0
        self.companies = {}
        self.products = {'A': 10.0, 'B': 15.0, 'C': 20.0}
        self.events = load_json('market_events.json')["events"]
        self.adjust_prices = lambda adjustment: {k: max(1, v + adjustment) for k, v in self.products.items()}
        self.event_effects = {"double": lambda x: x * 2, "halve": lambda x: x / 2, "increase": lambda x: x + 3.0,
                              "decrease": lambda x: max(1, x - 3.0)}
        self.stock_ledger = {}  # Initialize the stock ledger

        # Economic indicators
        self.inflation_rate = 0.02  # Example starting inflation rate (2%)
        self.unemployment_rate = 0.05  # Example starting unemployment rate (5%)
        self.gdp = 500000  # Example starting GDP value

    def update_stock_ledger(self, company_id, owner_id, amount):
        key = (company_id, owner_id)
        self.stock_ledger[key] = self.stock_ledger.get(key, 0) + amount

    def get_stock_ownership(self, company_id, owner_id):
        return self.stock_ledger.get((company_id, owner_id), 0)

    def get_stock_price(self, company_id):
        company_value = self.companies[company_id].get_value(self)
        return round(company_value / 100.0, 2)

    def update_market(self):
        self.current_turn += 1
        trend_adjustment = random.choice([2, -2, 0])

        # Adjust prices based on inflation
        self.products = self.adjust_prices(trend_adjustment)

        event = random.choices(self.events, weights=[e["probability"] for e in self.events])[0]
        if event["effect"] in ["new_competitor", "exit_competitor"]:
            self.handle_competitor_event(event["effect"])
        else:
            self.products = {k: self.event_effects[event["effect"]](v) for k, v in self.products.items()}

        self.update_economic_indicators()  # Update economic indicators each turn

    def adjust_prices(self):
        # Apply inflation more subtly and cumulatively
        for product, price in self.products.items():
            # Apply inflation
            inflation_adjustment = price * self.inflation_rate
            new_price = price + inflation_adjustment

            # Apply a very small random fluctuation for additional realism
            fluctuation = random.uniform(-0.03, 0.03)  # Slightly smaller range
            new_price += fluctuation

            # Ensure the price doesn't fall below a reasonable minimum (e.g., 1)
            new_price = max(1, new_price)

            # Update the price with rounding off to 2 decimal places
            self.products[product] = round(new_price, 2)

        return self.products

    def handle_competitor_event(self, effect):
        adjustment = random.randint(1, 3)
        self.products = {k: max(1, v - adjustment) if effect == "new_competitor" else v + adjustment for k, v in
                         self.products.items()}

    def update_economic_indicators(self):
        # Update the inflation rate based on market conditions
        self.inflation_rate += random.uniform(-0.01, 0.01)  # Random fluctuation
        self.inflation_rate = max(0, self.inflation_rate)  # Ensure non-negative

        # Update the unemployment rate
        self.unemployment_rate += random.uniform(-0.005, 0.005)  # Random fluctuation
        self.unemployment_rate = min(max(self.unemployment_rate, 0), 1)  # Bound between 0 and 1

        # Update GDP based on market performance
        self.gdp += self.gdp * (random.uniform(-0.01, 0.03) + self.inflation_rate)

    def calculate_final_scores(self):
        final_scores = {}
        for company_id, company in self.companies.items():
            final_score = company.get_value(self)

            # Determine the majority owner
            majority_owner = max(company.own_stock_ownership,
                                 key=lambda owner: (company.own_stock_ownership[owner], owner))
            majority_percentage = company.own_stock_ownership[majority_owner]

            # Check if the majority owner owns 51% or more
            is_major_owner = majority_percentage >= 51

            # Initialize or update the score
            if company_id not in final_scores:
                final_scores[company_id] = {'score': 0, 'note': ''}

            # Distribute scores
            for owner_id, percentage in company.own_stock_ownership.items():
                if percentage > 20:
                    score_transfer = final_score * (percentage / 100)
                    if owner_id not in final_scores:
                        final_scores[owner_id] = {'score': 0, 'note': ''}
                    final_scores[owner_id]['score'] += score_transfer

            # If no one owns 51% or more, assign the remainder to the company itself
            if not is_major_owner:
                remaining_score = final_score - sum(
                    final_scores.get(owner, {'score': 0})['score'] for owner in company.own_stock_ownership)
                final_scores[company_id]['score'] += remaining_score

            # Add a note about the majority owner
            final_scores[company_id]['note'] = f"Score has been added to {majority_owner}"

        return final_scores


class Company:
    def __init__(self, player_id, competitors_ids):
        self.player_id = player_id
        self.cash = 500.0
        self.inventory = {'A': 0, 'B': 0, 'C': 0}
        self.crafting_queue = []

        # Initialize stock ownership in the player's company
        self.own_stock_ownership = {player_id: 51}  # Player owns 51 shares of their company
        for cid in competitors_ids:
            self.own_stock_ownership[cid] = 0  # Competitors initially own no shares

        # Initialize stock holdings in other companies
        all_companies = competitors_ids + [player_id]
        self.other_stock_holdings = {cid: 0 for cid in all_companies}  # Player owns no shares in other companies initially

        self.total_shares = 100  # Total shares per company

    def get_value(self, market):
        return self.cash + sum(self.inventory[product] * price for product, price in market.products.items())

    def trade_product(self, market, product, quantity, buying):
        total_cost = round(market.products[product] * quantity, 2)
        print("\nProduct Trading Decision")
        products = list(market.products.keys())
        print("\nAvailable Products:")
        for idx, product in enumerate(products, 1):
            print(f" {idx}: {product}")
        product_choice = self.get_user_choice(len(products), "Choose a product to trade: ")
        product = products[product_choice - 1]

        quantity = self.get_valid_input("Enter the quantity to trade: ", int, "Quantity must be positive.",
                                        lambda x: x > 0)

        trade_type = self.get_user_choice(2, "Choose trade type (1: Buy, 2: Sell): ")
        self.trade_product(market, product, quantity, buying=trade_type == 1)

    def crafting_decision(self):
        print("\nCrafting Decision")
        recipe_keys = list(crafting_recipes.keys())
        print("\nAvailable Recipes:")
        for idx, recipe in enumerate(recipe_keys, 1):
            print(f" {idx}: {recipe}")
        recipe_choice = self.get_user_choice(len(recipe_keys), "Choose a recipe to craft: ")
        self.craft_product(recipe_keys[recipe_choice - 1])

    def trade_product(self, market, product, quantity, buying):
        total_cost = market.products[product] * quantity
        if buying:
            if self.cash >= total_cost:
                self.cash -= total_cost
                self.inventory[product] += quantity
        elif self.inventory[product] >= quantity:
            self.cash += total_cost
            self.inventory[product] -= quantity

    def craft_product(self, recipe_key):
        recipe = crafting_recipes[recipe_key]
        if all(self.inventory[product] >= quantity for product, quantity in recipe['input'].items()):
            for product, quantity in recipe['input'].items():
                self.inventory[product] -= quantity
            self.crafting_queue.append({'recipe': recipe, 'turns_remaining': recipe['turns']})
            print("Crafting order placed.")
        else:
            print("Not enough resources to craft.")

    def update_crafting(self):
        completed_orders = []
        for order in self.crafting_queue:
            order['turns_remaining'] -= 1
            if order['turns_remaining'] == 0:
                for product, quantity in order['recipe']['output'].items():
                    self.inventory[product] += quantity
                completed_orders.append(order)
        self.crafting_queue = [order for order in self.crafting_queue if order not in completed_orders]

    def trade_stock(self, action, market, company_id, amount):
        if company_id not in market.companies and company_id != self.player_id:
            print("Company not found in the market.")
            return

        stock_price = market.get_stock_price(company_id)
        total_value = stock_price * amount

        if action == 'buy':
            if company_id == self.player_id:
                # Calculate available shares in the player's company
                available_shares = self.total_shares - sum(self.own_stock_ownership.values()) + \
                                   self.own_stock_ownership[self.player_id]
            else:
                # Calculate available shares in an AI company
                available_shares = self.total_shares - self.other_stock_holdings[company_id]

            if amount > available_shares:
                print(f"Not enough available shares to buy. Available: {available_shares}")
                return

            if self.cash < total_value:
                print("Insufficient funds to buy stocks.")
                return

            self.cash -= total_value
            if company_id == self.player_id:
                # Buying shares of the player's own company
                self.own_stock_ownership[self.player_id] += amount
            else:
                # Buying shares of an AI company
                self.other_stock_holdings[company_id] += amount

            print(f"Bought {amount} stocks of {company_id}.")

        elif action == 'sell':
            if company_id == self.player_id:
                # Selling shares of the player's own company
                if self.own_stock_ownership[self.player_id] < amount:
                    print("Not enough stocks to sell.")
                    return
                self.own_stock_ownership[self.player_id] -= amount
            else:
                # Selling shares of an AI company
                if self.other_stock_holdings.get(company_id, 0) < amount:
                    print("Not enough stocks to sell.")
                    return
                self.other_stock_holdings[company_id] -= amount

            self.cash += total_value
            print(f"Sold {amount} stocks of {company_id}.")

    def make_decision(self, market, competitors):
        console = Console()

        # Enhanced table for player's status with Euro symbol
        status_table = Table(title=f"[bold green]{self.player_id}'s Turn - Turn {market.current_turn}", box=box.ROUNDED)

        status_table.add_column("Category", justify="left", style="bold cyan")
        status_table.add_column("Details", justify="left")

        # Use colors to highlight key data
        status_table.add_row("Cash", f"[bold yellow]{self.cash:.2f} €")
        status_table.add_row("Inventory", ', '.join(
            [f"[bold magenta]{item}: {quantity}" for item, quantity in self.inventory.items()]))
        status_table.add_row("Market Prices", ', '.join(
            [f"[bold blue]{product}: {price:.2f} €" for product, price in market.products.items()]))

        # Display shareholders and investments with color coding
        shareholders = ', '.join(
            [f"[bold]{company}[/]: {ownership} shares" for company, ownership in self.own_stock_ownership.items()])
        status_table.add_row("Your Shareholders", shareholders)

        investments = ', '.join(
            [f"[bold]{company}[/]: {holding} shares" for company, holding in self.other_stock_holdings.items() if
             holding > 0])
        status_table.add_row("Your Investments", investments)

        console.print(status_table)

        # Actions menu with clear choices
        actions = {
            "1": "Trade Products",
            "2": "Craft",
            "3": "Trade Stocks",
            "4": "Skip Turn"
        }

        # Display the choices to the player in an intuitive way
        choices_display = "\n".join([f"{key}: {value}" for key, value in actions.items()])
        console.print(f"Available Actions:\n{choices_display}", style="bold")

        # Prompt for action choice
        action_choice = Prompt.ask("Choose your action", choices=list(actions.keys()), default="4")

        # Perform the selected action
        selected_action = actions.get(action_choice, None)

        if selected_action == "Trade Products":
            self.trade_products_decision(market)
        elif selected_action == "Craft":
            self.crafting_decision()
        elif selected_action == "Trade Stocks":
            stock_actions = ["Buy", "Sell"]
            stock_action_choice = Prompt.ask("Choose stock action", choices=stock_actions, default=stock_actions[0])
            self.trade_stocks_decision(stock_action_choice.lower(), market, competitors)
        elif selected_action == "Skip Turn":
            pass  # Skip turn
        else:
            console.print("[bold red]Invalid choice. Please enter a valid option.")

    def trade_products_decision(self, market):
        print("\nProduct Trading Decision")
        products = list(market.products.keys())
        print("\nAvailable Products:")
        for idx, product in enumerate(products, 1):
            print(f" {idx}: {product} - Price: {market.products[product]},00 €")
        product_choice = self.get_user_choice(len(products), "Choose a product to trade: ")
        product = products[product_choice - 1]

        quantity = self.get_valid_input("Enter the quantity to trade: ", int, "Quantity must be positive.",
                                        lambda x: x > 0)

        trade_type = self.get_user_choice(2, "Choose trade type (1: Buy, 2: Sell): ")
        self.trade_product(market, product, quantity, buying=trade_type == 1)

    def trade_stocks_decision(self, action, market, competitors):
        print("\nStock Trading Decision")
        if action == 'buy':
            print("Available companies to buy stocks from:")
        elif action == 'sell':
            print("Your stock holdings:")

        # Include the player's company in the list
        companies = competitors + [self]  # Assuming 'self' represents the player's company

        for idx, company in enumerate(companies, 1):
            company_id = company.player_id
            stock_info = f" {idx}: {company_id} - Current stock price: {market.get_stock_price(company_id)}"
            if action == 'sell' and self.other_stock_holdings.get(company_id, 0) > 0:
                stock_info += f", Owned: {self.other_stock_holdings[company_id]}"
            print(stock_info)

        company_choice = self.get_user_choice(len(companies), "Enter the company number to trade stocks: ")
        company_id = companies[company_choice - 1].player_id

        amount = self.get_valid_input("Enter the amount of stocks to trade: ", int, "Stock amount must be positive.",
                                      lambda x: x > 0)
        self.trade_stock(action, market, company_id, amount)

    @staticmethod
    def get_user_choice(num_options, prompt):
        choice = 0
        while choice < 1 or choice > num_options:
            try:
                choice = int(input(prompt))
                if choice < 1 or choice > num_options:
                    raise ValueError
            except ValueError:
                print(f"Please enter a number between 1 and {num_options}.")
        return choice

    @staticmethod
    def get_valid_input(prompt, input_type, error_message, validation_func=lambda x: True):
        while True:
            try:
                value = input_type(input(prompt))
                if not validation_func(value):
                    raise ValueError
                return value
            except ValueError:
                print(error_message)


class AICompany(Company):
    def __init__(self, player_id, competitors_ids):
        super().__init__(player_id, competitors_ids)
        self.last_action = "None"
        self.average_prices = {'A': 10, 'B': 15, 'C': 20}

    def update_average_prices(self, market):
        turn = market.current_turn
        for product, price in market.products.items():
            self.average_prices[product] = (self.average_prices[product] * (turn - 1) + price) / turn

    def is_market_boom(self, market):
        return all(price > 20 for price in market.products.values())

    def choose_best_crafting_option(self):
        return next((recipe_key for recipe_key, recipe in crafting_recipes.items()
                     if all(self.inventory[prod] >= qty for prod, qty in recipe['input'].items())), None)

    def perform_trade_action(self, market, action):
        if action == 'sell':
            for product, quantity in self.inventory.items():
                if quantity > 0:
                    self.trade_product(market, product, quantity, False)
                    self.last_action = f"Sold {quantity} of {product}"
                    break
        elif action == 'buy':
            for product, price in market.products.items():
                if price > 0:  # Check to avoid division by zero
                    quantity = self.cash // price
                    if quantity > 0:
                        self.trade_product(market, product, quantity, True)
                        self.last_action = f"Bought {quantity} of {product}"
                        break
                else:
                    print(f"Price for {product} is currently zero, skipping.")

    def perform_stock_action(self, market, action):
        company_id, amount = self.select_stock_action(market, action)
        if company_id:
            self.trade_stock(action, market, company_id, amount)

    def select_stock_action(self, market, action):
        if action == 'buy':
            company_id = random.choice(list(market.companies.keys()))
            amount = random.randint(1, 10)  # Random amount
            return company_id, amount
        elif action == 'sell':
            owned_stocks = [(comp_id, amount) for comp_id, amount in self.other_stock_holdings.items() if amount > 0]
            if owned_stocks:
                company_id, _ = random.choice(owned_stocks)
                amount = random.randint(1, self.other_stock_holdings[company_id])
                return company_id, amount
        return None, 0

    def attempt_crafting(self):
        recipe_key = self.choose_best_crafting_option()
        if recipe_key:
            self.craft_product(recipe_key)
            self.last_action = f"Started crafting {recipe_key}"


class RationalAI(AICompany):
    def make_decision(self, market, competitors):
        # Decides on actions based on market conditions and crafting opportunities
        if self.should_craft(market):
            self.attempt_crafting()
        elif self.is_market_boom(market) or market.current_turn > 7:
            self.perform_trade_action(market, 'sell')
        else:
            self.perform_trade_action(market, 'buy')
        self.perform_stock_action(market, random.choice(['buy', 'sell']))

    def should_craft(self, market):
        # Determines whether crafting is a good choice based on market conditions
        return not self.is_market_boom(market) and market.current_turn <= 7

    def attempt_crafting(self):
        # Attempts to craft an item if the conditions are favorable
        recipe_key = self.choose_best_crafting_option()
        if recipe_key:
            self.craft_product(recipe_key)
            self.last_action = f"Started crafting {recipe_key}"


class RiskTakingAI(AICompany):
    def make_decision(self, market, competitors):
        # Randomly chooses to buy or sell based on market conditions or a 50-50 chance
        if random.choice([True, False]):
            self.perform_trade_action(market, 'buy')
        elif self.should_craft(market):
            self.attempt_crafting()
        else:
            self.perform_trade_action(market, 'sell')
        self.perform_stock_action(market, random.choice(['buy', 'sell']))

    def should_craft(self, market):
        # Decides whether to craft based on market conditions or randomly
        return random.choice([True, False]) if self.is_market_boom(market) else market.current_turn <= 7

    def attempt_crafting(self):
        # Attempts to craft a product if possible
        recipe_key = self.choose_best_crafting_option()
        if recipe_key:
            self.craft_product(recipe_key)
            self.last_action = f"Started crafting {recipe_key}"


def print_ai_actions(ai_competitors):
    for ai in ai_competitors:
        print(f"{ai.player_id} last action: {ai.last_action}")


def main():
    competitors_ids = ["Player", "Rational AI", "Risk-Taking AI"]
    market = Market()
    player = Company("Player", [id for id in competitors_ids if id != "Player"])
    ai_competitors = [RationalAI("Rational AI", [id for id in competitors_ids if id != "Rational AI"]),
                      RiskTakingAI("Risk-Taking AI", [id for id in competitors_ids if id != "Risk-Taking AI"])]

    # Initialize market with references to companies
    market.companies = {"Player": player, "Rational AI": ai_competitors[0], "Risk-Taking AI": ai_competitors[1]}

    for turn in range(10):
        print(f"\n---\n")
        market.update_market()
        player.update_crafting()
        player.make_decision(market, ai_competitors)

        for ai in ai_competitors:
            ai.make_decision(market, ai_competitors)
            ai.update_crafting()

        print_ai_actions(ai_competitors)

    # Calculate final scores based on company values and stock ownership
    final_scores = market.calculate_final_scores()

    print("\nFinal Company Values:")
    for company_id, value in final_scores.items():
        print(f"{company_id}: {value}")


if __name__ == "__main__":
    main()