import math
from threading import Thread

import soundfile


def level_cross(levels, a, b):
    a_level = 0
    b_level = 0
    if a > b:
        a, b = b, a
    for i in range(len(levels)):
        if a < levels[i]:
            a_level = i
            break
    for i in range(len(levels)):
        if b < levels[i]:
            b_level = i
            break
    return range(a_level, b_level)

path = 'sig0003.wav'
data, rate = soundfile.read(path)

N = 32

# нахождение минимального и максимального u, подсчёт дельты
umax = max(data)
umin = min(data)
deltaU = (umax - umin) / N

# вычисление напряжения эл. сигнала на уровнях
u_levels = [(i - N / 2) * deltaU for i in range(N)]

# просто нулевые значения, чтобы потом посчитать
S = 0
_N = [0 for i in range(N)]

# подсчет количества пересечений сигналом для каждого уровня (если пересекает) в j-ый интервал времени
for j in range(1, len(data)):
    increase_list = level_cross(u_levels, data[j - 1],
                                data[j])  # метод, которые подсчитывает пересечения, реализация выше
    if increase_list:
        for index in increase_list:
            _N[index] += 1

# количество пересечений всех уровней - S
for value in _N:
    S += value

# вероятности пересечения каждого уровня
p = [_N[i] / S for i in range(N)]

# среднее напряжение
u_avg = 0
for i in range(N):
    u_avg += u_levels[i] * p[i]

# среднеквадратическое значение напряжения
sigma = 0
for i in range(N):
    sigma += (u_levels[i] - u_avg) * (u_levels[i] - u_avg) * p[i]
sigma = math.sqrt(sigma)

# энтропия закона распределения мгновенных значений напряжений
H = 0
for i in range(N):
    if p[i] != 0:
        H -= p[i] * math.log(p[i])

# энтропийный коэффициент качества мгновенных значений напряжений
nu_M = math.exp(H) / math.sqrt(2 * math.pi * sigma * sigma)

print(f'nu_M = {nu_M}')

y = [0 for value in data]

file = open(path + '.u', 'w')
file.write(str(len(data)) + '\n')
for value in data:
    file.write(str(value) + '\n')
file.close()

print('continue?')
input()

file = open(path + '.u.y', 'r')
for i in range(len(data)):
    y[i] = float(file.readline())
file.close()

# подсчёт уровня напряжения огибающей электрического сигнала
U = [math.sqrt(data[j] * data[j] + y[j] * y[j]) for j in range(len(data))]

Umax = max(U)
Umin = min(U)

N0 = int((Umax - Umin) / deltaU)

# вычисление напряжения огибающей эл. сигнала на уровнях
U_levels = [(i - N0 / 2) * deltaU for i in range(N0)]
# U_levels = [Umin + i * deltaU for i in range(N0)]

S0 = 0
_N0 = [0 for i in range(len(U_levels))]

# подсчет количества пересечений огибающей сигнала для каждого уровня (если пересекает) в j-ый интервал времени
for j in range(1, len(U)):
    increase_list = level_cross(U_levels, U[j - 1], U[j])
    if increase_list:
        for index in increase_list:
            _N0[index] += 1

# количество пересечений огибающей всех уровней - S
for value in _N0:
    S0 += value

# вероятности пересечения огибающей каждого уровня
p0 = [_N0[i] / S0 for i in range(len(U_levels))]

sigma0_sqr = 0
for i in range(N0):
    sigma0_sqr += U_levels[i] * U_levels[i] * p0[i]

m = 0
for i in range(N0):
    if U_levels[i] > 0:
        m += p0[i] * math.log(U_levels[i])

H0 = 0
for i in range(N0):
    if p0[i] != 0:
        H0 -= p0[i] * math.log(p0[i])

c = 0.577
r = math.sqrt(2) * math.exp(1 + m + (c - sigma0_sqr) / 2)

Hp = -m + 2 * math.log(r) + sigma0_sqr / (2 * r * r)

nu0 = math.exp(H0 - Hp)

nu_result = nu_M * nu0

print(nu_result)