# 連続する同じコードを削除する
def eraseSameChord(chordSeqs):
	key = ''
	seqTexts = []
	for chord in chordSeqs:
		if key != chord:
			seqTexts.append(chord)
			key = chord
	return seqTexts

# 重複コード検出
def detectSequence(chordSeqs):
	seqTexts = []
	seqLength = len(chordSeqs)
	for ival in range(1,seqLength-4):
		duplicate = [0] * (seqLength-ival)
		for pos in range(0,seqLength-ival):
			if chordSeqs[pos+ival] == chordSeqs[pos]:
				duplicate[pos] += 1

		dupText = ''
		dupCnt = 0
		for pos, dup in enumerate(duplicate):
			if dup==1:
				dupCnt += 1
				if len(dupText)==0:
					dupText += chordSeqs[pos]
				else:
					dupText += '>'
					dupText += chordSeqs[pos]
			else:
				if dupCnt>=4:
					seqTexts.append(dupText)
				dupCnt = 0
				dupText = ''
		if dupCnt>=4:
			seqTexts.append(dupText)
	return seqTexts

# 同じコード進行をカウントおよび削除する
def aggregateSequence(chordSeqs):
	chordSeqs.sort()
	uniqTexts = [chordSeqs[0]]
	key = chordSeqs[0]
	cnt = 1
	dic = {}
	i = 0
	for text in chordSeqs:
		if key != text:
			dic[i] = cnt
			i += 1
			cnt = 1
			uniqTexts.append(text)
			key = text
		else:
			cnt += 1
	if key == text:
		dic[i] = cnt
		i += 1

	chordSeqs = []
	for k,v in sorted(dic.items(), key=lambda x:x[1], reverse=True):
		chordSeqs.append(uniqTexts[k])
		print(v,':',uniqTexts[k])

	return chordSeqs

# コード列を特定のコード列で分割する
def separateSequence(separator,chordSeqs):
	seqTexts = []
	if separator not in chordSeqs:
		return chordSeqs
	for text in chordSeqs:
		#print("text=",text)
		if separator not in text:
			seqTexts.append(text)
		elif text == separator:
			seqTexts.append(separator)
		else:
			tokens = text.split(separator)
			for token in tokens:
				if token != '':
					#print("token=",token)
					sepTokens = token.split('>')
					tmp = []
					for sepToken in sepTokens:
						if sepToken != '':
							tmp.append(sepToken)
					if len(tmp) > 4:
						editToken = '>'.join(tmp)
						#print("append-editToken=",editToken)
						seqTexts.append(editToken)
	return seqTexts

# コードの先頭と末尾が同じ場合、末尾のコードを削除する
def checkBothEnds(chordSeqs):
	seq = []
	for key, seqText in enumerate(chordSeqs):
		seq = seqText.split('>')
		endPos = len(seq) - 1
		if seq[0] == seq[endPos]:
			seq.pop(endPos)
			chordSeqs[key] = '>'.join(seq)
	return chordSeqs

# 重複するコード進行を削除する
def removeDuplicate(chordSeqs):
	chordSeqs.sort()
	uniqSeq = []
	uniqSeq = [chordSeqs[0]]
	key = chordSeqs[0]
	for text in chordSeqs:
		if key != text:
			uniqSeq.append(text)
			key = text
	return uniqSeq

# 構成しているコードの数でソートする
def sortSequence(chordSeqs):
	dic = {}
	newSeq = []
	for i, seq in enumerate(chordSeqs):
		dic[i] = len(seq.split('>'))
	for k,v in sorted(dic.items(), key=lambda x:x[1]):
		newSeq.append(chordSeqs[k])
	return newSeq

# コード進行の解析結果表示
def editSequence(chordSeqs,chordText):
	colors = ['red','fuchsia','lime','blue','aqua','purple','green','navy','teal']
	chordText = chordText.replace('>','>')
	for i, text in enumerate(chordSeqs):
		tmp = text.replace('>','>')
		reptext = '[' + tmp + ']'
		chordText = chordText.replace(tmp,reptext)
	return chordText

chordText = 'E>B>C＃m>A>E>B>C＃m>A>E>E>A>A>EonG＃>F＃m>F＃m>B>B>E>E>A>A>EonG＃>F＃m>F＃m>B>B>E>B>C＃m>D>Bsus4>B>E>B>C＃m>D>B>A>BonA>G＃m>C＃m>F＃m>B>E>F＃m>B>G＃m>C＃m>F＃m>G＃m>A>F＃onA＃>B>E>B>C＃m>Bm>A>G＃m>C＃>C＃onB>F＃m>G＃m>Am>B>E>B>C＃m>Bm>A>G＃m>C＃>C＃onB>F＃m>G＃m>Am>B>E>E>A>A>EonG＃>F＃m>F＃m>B>B>E>B>C＃m>D>Bsus4>B>E>B>C＃m>D>B>A>BonA>G＃m>C＃m>F＃m>B>E>F＃m>B>G＃m>C＃m>F＃m>G＃m>A>F＃onA＃>B>E>B>C＃m>Bm>A>G＃m>C＃>C＃onB>F＃m>G＃m>Am>B>E>B>C＃m>Bm>A>G＃m>C＃>C＃onB>F＃m>G＃m>Am>B>EonG＃>EonG＃>A>A>EonG＃>EonG＃>A>A>EonG＃>EonG＃>A>A>F＃m>F＃m>B>B>B>B>E>B>C＃m>Bm>A>G＃m>C＃>C＃onB>F＃m>G＃m>Am>B>E>B>C＃m>Bm>A>G＃m>C＃>C＃onB>F＃m>G＃m>Am>B>E>E>A>A>EonG＃>F＃m>F＃m>B>B>E>E>A>A>EonG＃>F＃m>F＃m>B>B>E'
print(chordText)
chordSeqs = chordText.split('>')

print("---------- eraseSameChord(chordSeqs) ----------")
# 連続する同じコードを削除する
chordSeqs = eraseSameChord(chordSeqs)
chordText = '>'.join(chordSeqs)
print(chordText)

# 重複コード検出
chordSeqs = detectSequence(chordSeqs)

print("---------- aggregateSequence(chordSeqs) ----------")
# 同じコード進行をカウントおよび削除する
chordSeqs = aggregateSequence(chordSeqs)
separator = chordSeqs[0]

print("---------- separateSequence(separator,chordSeqs) ----------")
# コード列を特定のコード列で分割する
chordSeqs = separateSequence(separator,chordSeqs)
for text in chordSeqs:
	print(text)

print("---------- checkBothEnds(chordSeqs) ----------")
# コードの先頭と末尾が同じ場合、末尾のコードを削除する
chordSeqs = checkBothEnds(chordSeqs)
for text in chordSeqs:
	print(text)

print("---------- removeDuplicate(chordSeqs) ----------")
# 重複するコード進行を削除する
chordSeqs = removeDuplicate(chordSeqs)
for text in chordSeqs:
	print(text)

print("---------- sortSequence(chordSeqs) ----------")
# 構成しているコードの数でソートする
chordSeqs = sortSequence(chordSeqs)
for text in chordSeqs:
	print(text)

print("---------- separateSequence(text,seqTexts)/sortSequence(seqTexts) ----------")
# コード列を特定のコード列で分割する
seqTexts = chordSeqs
for text in chordSeqs:
	seqTexts = separateSequence(text,seqTexts)

# 構成しているコードの数でソートする
seqTexts = sortSequence(seqTexts)
for text in seqTexts:
	print(text)

print("---------- removeDuplicate(seqTexts) ----------")
# 重複するコード進行を削除する
chordSeqs = removeDuplicate(seqTexts)
for text in chordSeqs:
	print(text)

print("---------- editSequence(chordSeqs,chordText) ----------")
# コード進行の解析結果表示
chordText = editSequence(chordSeqs,chordText)
print(chordText)