# (c) Reflection 2026 Baltasar MIT License <jbgarcia@uvigo.es>


def to_dict(obj):
    id_members = dir(obj)
    toret = {}

    for id_member in id_members:
        val = getattr(obj, id_member)
        toret[id_member] = val
            
    return toret


def to_str_list(obj):
    members = to_dict(obj)
    toret = type(obj).__name__ + ":\n"

    for id_member in members.keys():
        val = getattr(obj, id_member)
        if callable(val):
            toret += "\t" + id_member + "()\n"
        else:
            qt = ""
            if isinstance(val, str):
                qt = '\"'
            toret += f"\t{id_member}: {qt}{val}{qt}\n"
            
    return toret
    
    
class SuperHero:
    def __init__(self, name, alter_ego, power):
        self._name = name
        self._alter_ego = alter_ego
        self._power = power
        self._transformed = False
        
    def transform(self):
        self._transformed = not(self._transformed)
        
    def __getattr__(self, atr_name):
        if atr_name == "name":
            return self._alter_ego if self._transformed else self._name
        
        if atr_name == "power":
            return 0 if not self._transformed else self._power
        
        if atr_name == "is_transformed":
            return lambda: self._transformed
        
        return AttributeError(atr_name)
    
    def __getattribute__(self, atr_name):
        if (atr_name == "transform"
        and self._name == "Bruce Banner"
        and self._transformed):
                return lambda: None

        return super().__getattribute__(atr_name)
    
    def __str__(self):
        return f"{self.name}/{self.power} {'*' if self.is_transformed() else ''}"


class Struct:
    def __setattr__(self, atr_name, val):
        self.__dict__["_" + atr_name] = val
        
    def __getattr__(self, atr_name):
        toret = self.__dict__["_" + atr_name]
        
        if not toret:
            raise AttributeError(atr_name)
        
        return toret
    
    def __str__(self):
        pairs = self.__dict__.items()
        return ("{"
                + str.join(", ", [pair[0][1:] + ": " + str(pair[1]) for pair in pairs])
                + "}")
    
    
class Sequence:
    def __init__(self):
        self._l = []
        
    def __iadd__(self, val):
        self._l.append(val)
        return self

    def __getitem__(self, item):
        return self._l[item]
    
    def __len__(self):
        return len(self._l)
    
    def __str__(self):
        return str.join(", ", [str(x) for x in self._l])


def chk_listing():
    from superhero import SuperHero
    
    s1 = SuperHero("Clark Kent", "Superman", 100_000_000)
    print(to_dict(s1))
    print(to_dict(123))
    print(to_dict("a"))
    
    print(to_str_list(s1))
    print(to_str_list(123))
    print(to_str_list("a"))


def chk_superheroes():
    superheroes = [
        SuperHero("Clark Kent", "Superman", 100000000),
        SuperHero("Bruce Banner", "Hulk", 100000)]

    print("--- Pasando de humanos normales a superhéroes")
    for superhero in superheroes:
        print(f"\n{superhero}")
        superhero.transform()
        print(superhero)
        
    print("\n\n--- Transformando a Hulk (pero no se puede)")
    superheroes[1].transform()
    print(superheroes[1])


def chk_sequence():
    s1 = Sequence()
    s1 += 0x000000
    s1 += 0x0000ff
    s1 += 0xff00ff
    s1 += 0x00ff00
    s1 += 0x00ffff
    s1 += 0xffffff
    
    for i, color in enumerate(s1):
        print(f"Color {i + 1}:", color)
        
    print(s1)
    print(f"#s1={len(s1)}, s1[2]={s1[2]}")
    
    
def chk_struct():
    s1 = Struct()
    s1.model = "A3"
    s1.maker = "Audi"
    s1.style = "Sportback"
    s2 = Struct()
    s2.name = "Raymond Poulidor"
    s2.team = "Mercier"
    print(s1)
    print(f"{s1.maker} {s1.model} {s1.style}")
    print(s2)
    print(f"{s2.name} ({s2.team})")
    

if __name__ == "__main__":
    #chk_listing()
    #chk_struct()
    #chk_superheroes()
    chk_sequence()