import json
import sys
import random
import JsonHandling as JsonHandling
from collections import defaultdict
import energyuser as energyuser
import random

class EnergyUser:
    def __init__(self, config):
        self.ID = config.get("ID")
        self.user_prio = config.get("user_prio", 0)
        self.lock_prio = config.get("lock_prio", 0)
        self.idle = True
        self.used_energy = 0
        self.current_power = 0
        self.current_delta_power = 0

    def use_energy(self, amount):
        raise NotImplementedError("Subclasses must implement use_energy method")
        
    modular = False
    powersteps = []
    
    def get_requested_power(self):

                    max_power = max(self.powersteps)
                    return max_power if random.choice([True, False]) else max_power
                    return 0

class User1(EnergyUser):
    modular = True
    powersteps = [100, 600]
    
    def __init__(self, config):
        self.ID = config.get("ID")
        self.user_prio = config.get("user_prio", 0)
        self.lock_prio = config.get("lock_prio", 0)
        self.idle = True
        self.used_energy = 6
        self.current_power = 0
        self.current_delta_power = 0   
        
    def use_energy(self, amount):
        print(f"Using energy as {self.ID} with amount {amount}")
        # Hier kannst du die spezifische Logik für User 1 implementieren
   


class User2(EnergyUser):
    modular = False
    powersteps = [200, 400]
    
    def __init__(self, config):
        self.ID = config.get("ID")
        self.user_prio = config.get("user_prio", 0)
        self.lock_prio = config.get("lock_prio", 0)
        self.idle = True
        self.used_energy = 4
        self.current_power = 0
        self.current_delta_power = 0
        
        
    def use_energy(self, amount):
        print(f"Using energy as {self.ID} with amount {amount}")
        # Hier kannst du die spezifische Logik für User 2 implementieren
        


class EnergyUserFactory:
    @staticmethod
    def create_from_json(json_data):
        subclasses = [cls for cls in sys.modules[__name__].__dict__.values() if isinstance(cls, type) and issubclass(cls, EnergyUser) and cls != EnergyUser]
    
        energy_users = []
        data = json.loads(json_data)
    
        for user_data in data["users"]:
            user_type = user_data["type"]
            user_config = user_data["config"]
            for subclass in subclasses:
                if user_type in subclass.__name__:
                    energy_users.append(subclass(user_config))
    
        return energy_users
    
        
        
        
    @staticmethod
    def get_current_available_power():
        a =  random.randint(0,3000)
        print(a)
        return a
    
    @staticmethod
    def distribute_energy(energy_users, current_power):
        remaining_power = current_power - sum(user.current_delta_power for user in energy_users)
        print(remaining_power)
        # Filtere Benutzer mit idle = True
        idle_energy_users = [user for user in energy_users if user.idle]
    
        # Erweitere die Schritte für modulare Benutzer
        for user in idle_energy_users:
            if user.modular:
                user.powersteps = list(range(min(user.powersteps), max(user.powersteps) + 1))
    
        # Sortiere die Benutzer nach ihrer Priorität und dann nach ihrer ID
        idle_energy_users.sort(key=lambda x: (x.user_prio, x.used_energy))
    
        # Schleife durch alle Prioritäten
        priorities = set(user.user_prio for user in idle_energy_users)
        for priority in priorities:
            # Benutzer mit gleicher Priorität sammeln
            same_priority_users = [u for u in idle_energy_users if u.user_prio == priority]
            if not same_priority_users:
                continue
    
            # Sammle alle Schritte der Benutzer in einem Array
            all_steps = []
            for user in same_priority_users:
                all_steps.extend([(user, step) for step in user.powersteps])
    
            # Sortiere die Schritte nach Größe
            all_steps.sort(key=lambda x: x[1])
    
            # Variable zur Verfolgung der bereitgestellten Energie für jeden Benutzer
            user_energy_prov = {user: 0 for user in same_priority_users}
    
            # Iteriere durch alle Schritte
            for user, powerstep in all_steps:
                # Überprüfe, ob noch genügend verbleibende Energie für den nächsten Schritt vorhanden ist
                if remaining_power >= powerstep - user_energy_prov[user]:
                    # Aktualisiere die verbleibende Energie und die bereitgestellte Energie für den Benutzer
                    remaining_power -= (powerstep - user_energy_prov[user])
                    user_energy_prov[user] = powerstep
    
            # Verteile die bereitgestellte Energie auf die Benutzer
            for user in same_priority_users:
                user.use_energy(user_energy_prov[user])
    
        print("Final state after distributing power:")
        for user in energy_users:
            print(f"{user.ID}: {user.used_energy}")

# Beispielverwendung
json_data = '''
{
  "metadata":{"config_has_changed" : "0"},
  "users": [
    {"type": "User1", "config": {"ID":"Umod1","user_prio":1,"lock_prio":2}},
    {"type": "User1", "config": {"ID":"Umod3","user_prio":3,"lock_prio":4}},
    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
    {"type": "User1", "config": {"ID":"Umod2","user_prio":2,"lock_prio":3}},
    {"type": "User2", "config": {"ID":"Usta2","user_prio":2,"lock_prio":6}},
    {"type": "User2", "config": {"ID":"Usta2","user_prio":2,"lock_prio":6}}
  ]
}

'''

#