1TONE_INDEX_DICT = {"C" : 0, "C#" : 1, "D" : 2, "D#" : 3, "E" : 4, "F" : 5, "F#" : 6, "G" : 7, "G#" : 8, "A" : 9, "A#" : 10, "B" : 11}
  2TONE_VALUE_LIST = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
  3INTERVAL_VALUE_LIST = ["unison", "minor 2nd", "major 2nd", "minor 3rd", "major 3rd", "perfect 4th", "diminished 5th", "perfect 5th", "minor 6th", "major 6th", "minor 7th", "major 7th"]
  4MAX_INDEX = 12
  5
  6class Tone:
  7    def __init__(self, name):
  8        self.name = name
  9    
 10    def __str__(self):
 11        return self.name
 12    
 13    def __add__(self, other):
 14        if isinstance(other, Tone):
 15            return Chord(self, other)
 16        if isinstance(other, Interval):
 17            total_len = other.lenght + self.index
 18            correct_index = int(total_len / MAX_INDEX)
 19            correct_len = total_len - correct_index*MAX_INDEX
 20            return Tone(TONE_VALUE_LIST[correct_len])
 21    
 22    def __sub__(self, other):
 23        if isinstance(other, Tone):
 24            len = self.index - other.index
 25            if self.index < other.index:
 26                len = self.index + MAX_INDEX - other.index
 27            return Interval(len)
 28        if isinstance(other, Interval):
 29            wanted_index = self.index - other.lenght
 30            if self.index < other.lenght:
 31                wanted_index = self.index - other.lenght + MAX_INDEX
 32            return TONE_VALUE_LIST[wanted_index]
 33    
 34    @property
 35    def index(self):
 36        return TONE_INDEX_DICT[self.name]
 37    
 38class Interval:
 39    def __init__(self, lenght):
 40        correct_index = int(lenght / MAX_INDEX)
 41        self.lenght = lenght - correct_index*MAX_INDEX
 42
 43    def __str__(self):
 44        return INTERVAL_VALUE_LIST[self.lenght]
 45    
 46    def __add__(self,other):
 47        if isinstance(other,Tone):
 48            raise TypeError("Invalid operation")
 49        if isinstance(other,Interval):
 50            total_len = self.lenght + other.lenght
 51            correct_index = int(total_len / MAX_INDEX)
 52            correct_len = total_len - correct_index*MAX_INDEX
 53            return INTERVAL_VALUE_LIST[correct_len]
 54        
 55    def __sub__(self,other):
 56        if isinstance(other,Tone):
 57            raise TypeError("Invalid operation")
 58        
 59    def __neg__(self):
 60        return Interval(MAX_INDEX - self.lenght)
 61
 62class Chord:
 63    def __init_sorted_tones(self):
 64        main_index = self.main_tone.index
 65        tones_dict = {self.main_tone.name : main_index}
 66        self.all_tones_list_objs = [self.main_tone]
 67        for tone_name in self.unique_tones:
 68            tone_index = Tone(tone_name).index
 69            self.without_main_tones_list_objs.append(Tone(tone_name))
 70            self.all_tones_list_objs.append(Tone(tone_name))
 71            if main_index > tone_index:
 72                tones_dict[tone_name] = tone_index + MAX_INDEX
 73            else:
 74                tones_dict[tone_name] = tone_index
 75        self.sorted_tones = [key for key, value in sorted(tones_dict.items(), key=lambda item: item[1])]
 76
 77    def __init__(self, main_tone, *tones):
 78        self.main_tone = main_tone
 79        self.unique_tones= set()
 80        self.sorted_tones = []
 81        self.all_tones_list_objs = []
 82        self.without_main_tones_list_objs = []
 83        self.unique_tones.add(main_tone.name)
 84        for tone in tones:
 85            self.unique_tones.add(tone.name)            
 86        valid_len = len(self.unique_tones)
 87        if valid_len <= 1:
 88            raise TypeError("Cannot have a chord made of only 1 unique tone")
 89        self.unique_tones.discard(main_tone.name)
 90        self.__init_sorted_tones()
 91        
 92    def __add__(self, other):
 93        new_tones = self.without_main_tones_list_objs
 94        if isinstance(other, Tone):
 95            new_tones.append(other)
 96        if isinstance(other,Chord):
 97            for tone in other.all_tones_list_objs:
 98                new_tones.append(tone)
 99        return Chord(self.main_tone, *new_tones)
100
101    def __sub__(self, other):
102        if other.name not in self.sorted_tones:
103            raise TypeError(f"Cannot remove tone {other.name} from chord {self}")
104        if len(self.unique_tones) < 2:
105            raise TypeError("Cannot have a chord made of only 1 unique tone")
106        new_tones = self.without_main_tones_list_objs
107        main_tone = self.main_tone
108        if isinstance(other, Tone):
109            if main_tone.name == other.name:
110                main_tone = self.without_main_tones_list_objs[0]
111                new_tones = filter(lambda tone: tone.name != main_tone.name, new_tones)
112            else:
113                new_tones = filter(lambda tone: tone.name != other.name, new_tones)
114        return Chord(main_tone, *new_tones)      
115
116    def __str__(self):    
117        return "-".join(self.sorted_tones)
118    
119    def is_minor(self):
120        for tone in self.without_main_tones_list_objs:
121            interval = tone - self.main_tone
122            if str(interval) == "minor 3rd":
123                return True
124        return False
125    
126    def is_major(self):
127        for tone in self.without_main_tones_list_objs:
128            interval = tone - self.main_tone
129            if str(interval) == "major 3rd":
130                return True
131        return False
132    
133    def is_power_chord(self):
134        return not self.is_major() and not self.is_minor() 
135    
136    def transposed(self, interval):
137        transposed_tones = [tone + interval for tone in self.all_tones_list_objs]
138        return Chord(transposed_tones[0], *transposed_tones[1:])