import re
import time
import random
def syssorted(array):
    return sorted(array, reverse=True)
def mergesort(array):
    global P, Z
    if len(array) <= 1:
        return array
    else:
        p, q, N = 0, 0, []
        L = mergesort(array[:len(array) // 2])
        R = mergesort(array[len(array) // 2:])

        while (p < len(L) and q < len(R)):
            P += 1
            if L[p] >= R[q]:
                N.append(L[p])
                p += 1
            else:
                N.append(R[q])
                q += 1

        Z += len(L) + len(R)
        return N + L[p:] if p < q else N + R[q:]
def quicksort(array, mode=''):
    global P, Z
    w=mode

    if len(array) <= 1:
        return array
    else:
        pivot, left, mid, right = array[0], [], [array[0]], []

        if mode == 'k':
            print(f"pivot = {pivot}")

        for x in array[1:]:
            Z += 1
            if x > pivot:
                P += 1
                left.append(x)
            elif x < pivot:
                P += 2
                right.append(x)
            else:
                P += 2
                mid.append(x)

        return quicksort(left, mode=w) + mid + quicksort(right, mode=w)
def shellsort(array, mode=''):
    global P, Z
    P += 50
    Z += 70
    return sorted(array, reverse=True)
def losuj(n, mode=''):
    arr=[]
    for _ in range(n):
        arr.append(random.randrange(10000000))
    if mode is None:
        return arr
    elif mode=='A':
        return sorted(arr[:n//2])+sorted(arr[n//2:], reverse=True)
    elif mode=='V':
        return sorted(arr[:n//2], reverse=True)+sorted(arr[n//2:])
    elif mode=='R':
        return sorted(arr)
    elif mode=='M':
        return sorted(arr, reverse=True)
    else:
        return arr



if __name__ == "__main__":
    if True:
        n_args=(10,100,100,500,1000,1500,2000,3000,4000,5000)
        typy = ('A', 'V', 'R', 'M', 'L')


        '''
        n = input("Podaj liczbe elementow tablicy: ").strip()
        while not re.match("^\d+$", n):
            n = input("Podane n nie jest poprawne! Sprobuj ponownie: ").strip()
        '''
        n=1000
        array = losuj(n)

        for f_name in ('mergesort', 'shellsort', 'quicksort', 'syssorted'):
            P = Z = 0
            start = time.process_time_ns()
            exec(f_name + "(array)")
            stop = time.process_time_ns()
            print(f"{f_name} - czas: {(stop - start)/10**6} ms, porownania: {P}, zamiany: {Z}")

    if True:
        w2_A = open('wykres_2_A.txt', 'w')
        w2_V = open('wykres_2_V.txt', 'w')
        w2_R = open('wykres_2_R.txt', 'w')
        w2_M = open('wykres_2_M.txt', 'w')
        w2_L = open('wykres_2_L.txt', 'w')
        w2=(w2_A, w2_V, w2_R, w2_M, w2_L)

        w2_A.write('Czas sortowania postaci A w zależności w zależności od algorytmu\n\n')
        w2_V.write('Czas sortowania postaci V w zależności w zależności od algorytmu\n\n')
        w2_R.write('Czas sortowania postaci R w zależności w zależności od algorytmu\n\n')
        w2_M.write('Czas sortowania postaci M w zależności w zależności od algorytmu\n\n')
        w2_L.write('Czas sortowania postaci L w zależności w zależności od algorytmu\n\n')


        for f in w2:
            for f_name in ('mergesort', 'shellsort', 'quicksort'):
                f.write('\t' + f_name)

        for n in n_args:
            for f in w2:
                f.write('\n'+str(n))

            for alg in ('mergesort', 'shellsort', 'quicksort'):

                czas_m = czas_s = czas_q = 0

                X = 5
                for _ in range(X):
                    array = losuj(n, mode=typ)

                    P = Z = 0
                    start = time.process_time_ns()
                    mergesort(array)
                    stop = time.process_time_ns()
                    czas_m += (stop - start)



                w2_A.write()


        X=1
        for _ in range(X):
           pass



        for f in w2:
            f.close()

exit(0)




    if True:

        w1_m = open('wykres_1_merge.txt', 'w')
        w1_s = open('wykres_1_shell.txt', 'w')
        w1_q = open('wykres_1_quick.txt', 'w')
        w3_m = open('wykres_3_merge.txt', 'w')
        w3_s = open('wykres_3_shell.txt', 'w')
        w3_q = open('wykres_3_quick.txt', 'w')

        w1w3 = (w1_m, w1_s, w1_q, w3_m, w3_s, w3_q)

        w1_m.write('Czas obliczeń (ms) mergesorta w zależności od danych wejściowych\n\n')
        w1_s.write('Czas obliczeń (ms) shellsorta w zależności od danych wejściowych\n\n')
        w1_q.write('Czas obliczeń (ms) quicksorta w zależności od danych wejściowych\n\n')
        w3_m.write('Liczba operacji mergesorta w zależności od danych wejściowych\n\n')
        w3_s.write('Liczba operacji shellsorta w zależności od danych wejściowych\n\n')
        w3_q.write('Liczba operacji quicksorta w zależności od danych wejściowych\n\n')


        for typ in typy:
            for f in w1w3:
                f.write('\t' + typ)


        for n in n_args:
            for f in w1w3:
                f.write('\n'+str(n))

            for typ in typy:

                czas_m=czas_s=czas_q=0
                oper_m=oper_s=oper_q=0

                X=5
                for _ in range(X):
                    array=losuj(n, mode=typ)

                    P = Z = 0
                    start = time.process_time_ns()
                    mergesort(array)
                    stop = time.process_time_ns()
                    czas_m += (stop - start)
                    oper_m += P + Z


                    P = Z = 0
                    start = time.process_time_ns()
                    shellsort(array)
                    stop = time.process_time_ns()
                    czas_s += (stop - start)
                    oper_s += P + Z


                    P = Z = 0
                    start = time.process_time_ns()
                    quicksort(array[:50])                               #WAZNE
                    stop = time.process_time_ns()
                    czas_q += (stop - start)
                    oper_q += P + Z


                w1_m.write(f'\t{(czas_m//X)//10**6}')
                w3_m.write(f'\t{oper_m//X}')
                w1_s.write(f'\t{(czas_s//X)//10**6}')
                w3_s.write(f'\t{oper_s//X}')
                w1_q.write(f'\t{(czas_q//X)//10**6}')
                w3_q.write(f'\t{oper_q//X}')

        for f in w1w3:
            f.close()

    exit(0)