library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity compare is
    -- Wartośd pomocnica równa 41 ( długośd wiersza pomniejszona o 1 )
    generic (N : integer := 41);
    port(
    -- reset + zegar do sterowania automatem
    rst, clk : in std_logic;
    -- Szukane słowo (10-bitowy wyróżnik+bajt)
    word: in std_logic_vector (17 downto 0);
    --Adres słowa (dokłady opis w dokumentacji)
    out_cell : out std_logic_vector (12 downto 0)
);
end entity compare;

architecture porownaj of compare is
    --32 wiersze o dlugosci N
    type memory is array (31 downto 0) of std_logic_vector (N downto 0);
    --idle - stan jałowy, search_wyr - wyszukiwanie wyróżnika, search_byte - wyszukiwanie bajtu, found - znaleziony
    type stan is (idle, search_byte, search_wyr, found);
   --stany automatu, nastepny stan
   signal state, next_state : stan;
    --Pamięd podręczna: 32 wiersze po 4 bajty każdy.
    signal mem: memory;
    --Przeszukiwany wiersz pamięci. Zmienia się, jeśli wyróżnik nie pasuje
    signal x : std_logic_vector (N downto 0);
    --x8- Porównywany bajt z pamięci, y8-Szukany bajt, compare8- Pokazuje na których miejscach porównywane bajty są zgodne
    signal x8, y8, compare8: std_logic_vector (7 downto 0);
    --x10-Porównywany wyróżnik z pamięci, y10-Szukany wyróżnik, compare10-Pokazuje na których miejscach porównywane wyróżniki są zgodne
    signal x10,y10, compare10: std_logic_vector (9 downto 0);
    --out8, out10-pokazują czy porównywane bajty/wyróżniki są takie same czy różne, ew. komparator nie pracuje
    signal out8, out10, in8, in10, wup, bup: std_logic;
    --wnum-pokazyje który wiersz jest obecnie przeszukiwany, wn-sygnał pomocniczy
    signal wnum, wn : std_logic_vector (4 downto 0);
    --bnum-pokazuje który bajt jest obecnie przeszukiwany, bn-sygnał pomocniczy, found i fn-sterowanie out_cel sygnalizują znalezienie słowa
    signal bnum, bn, fn, fund : std_logic_vector (1 downto 0);

begin
    y8 <= word (7 downto 0);
    y10 <= word (17 downto 8);
    --mem-nasza pamięć w której bedziemy wyszukiwali
    mem <= ("101010001001100101000110101010100011100001","100100010000101010101011000010100100100101","010001000110010101010010011000010101010101","010000100101001011001001101000101110101101","100111100010011001010101101001010101011001","000011011101010010010000011000100110000110","100111001000101101101100110101001001010101","011010011001010001111110110101110100101010","100000010110101101010111010101011001000100","010010111010000001101010100110110110001111","100010010100101100010010100011000100001000","100111001100110101100010101001000100010100","010010101000000111100110100010111011100001","001000101001100111001001010010010101111011","001000000100101000101010010110010110110101","000110101101001100000100100110010110110001","101010100010110101010010011001000110110011","001001110110001010001111010110101011010101","110101001000010000100010001100000000001010","010010001000101001010010101000000010100000","001001000100100010010010001001010010000101","000000011101000100000100001011110100101100","101001100101011000000000000100110011010100","000010100100100110010011101101010101100100","110010101000010110010001000011100000010011","000100100001001100010010000010100011000000","000000010000100110101010011010101110101010","010000001001000000000011100000000001000101","000101000101000011010001010111000001110110","010001010000010000010010001000000010011001","001000010100100000001010000010011001000100","000100101010100010010000101100100100010100");
    sterownik: process(out8, out10, state, mem, y10, word, x, bnum, wnum, fn)

    constant I : integer := 41;

    begin
    --sterowanie stanem automatu
        case state is
        --szukanie wyróżnika, kiedy znajdzie wyróżnik zmienia się stan automatu, natomiast wartości liczników się nie zmieniają
        --komparator 8-bit jest wyłączony, a 10-bit włączony
        when search_wyr =>
            x10 <= x (I downto I-9);
            x8 <= x(I-10 downto I-17);
            in8 <= '0';
            in10 <= '1';
            --bajty takie same
            if ( out10 = '1') then
                next_state <= search_byte;
                fund <= "01";
                wup <= '0';
                bup <= '0';
                --wyróżniki różne, koniec przejście w stan jałowy
            elsif (out10 ='0' and wnum = "11111")then
                next_state <= idle;
                wup <= '0';
                bup <= '0';
                fund <= "00";
            else
            --przeszukaj następny wyróżnik
                next_state <= search_wyr;
                wup <= '1';
                bup <= '0';
                fund <= "01";
            end if;
            --przeszukiwanie bajtu

        --szukanie bajtu, kiedy znajdzie bajt zmienia się stan automatu, natomiast wartości liczników się nie zmieniają
        --komparator 8-bit jest wyłączony, a 10-bit włączony
        when search_byte =>
        --ozanaczenie przeszukiwanego bajtu
                case bnum is
                when "00" =>
                x8 <= x(31 downto 24);
                when "01" =>
                x8 <= x(23 downto 16);
                when "10" =>
                x8 <= x(15 downto 8);
                when others =>
                x8 <= x(7 downto 0);
                end case;
             x10 <= x(I downto I-9);
             in8 <= '1';
             in10 <= '0';
             fund <= "01";
             --ostateczne znalezienie bajtu
            if (out8 = '1') then
                next_state <= found;
                wup <= '0';
                bup <= '1';
                --bajty różne, koniec przejście w stan jałowy
            elsif (out8 = '0' and bnum = "11") then
                next_state <= idle;
                fund <= "01";
                wup <= '0';
                bup <= '0';
            else
            --przeszukaj następny bajt
                next_state <= search_byte;
                wup <= '0';
                bup <= '1';
            end if;
            --znalezienie
        when found =>
            x8 <= x (I-10 downto I-17);
            x10 <= x (I downto I-9);
            in8 <= '0';
            in10 <= '0';
            next_state <= idle;
            fund <= "11";
            wup <= '0';
            bup <= '0';
            --nie znalezienie
        when others =>
            next_state <= idle;
            fund <= fn;
            in8 <= '0';
            in10 <= '0';
            wup <= '0';
            bup <= '0';
            x8 <= "00000000";
            x10 <= "0000000000";
        end case;
    end process;

    outcell: process (fund, state, y10, bnum)
    begin
        case state is
        when idle =>
        if (fund = "11") then
        out_cell <= '0' & y10 & bnum;
        elsif (fund = "00") then
        --nie znaleziono wyróżnika
        out_cell <= "1111111111111";
        else
        --nie znaleziono bajtu lub zresetowano układ
        out_cell <= "1000000000000";
        end if;
        when found =>
        out_cell <= '0' & y10 & bnum;
        when others =>
        --układ pracuje
        out_cell <= "0000000000000";
        end case;
    end process;


    -- multiplekser wybierający wiesz pamięci
    mul_w : process (wnum, mem)
    begin
        case wnum is
            when "00000" =>
            x <= mem(31);
            when "00001" =>
            x <= mem(30);
            when "00010" =>
            x <= mem(29);
            when "00011" =>
            x <= mem(28);
            when "00100" =>
            x <= mem(27);
            when "00101" =>
            x <= mem(26);
            when "00110" =>
            x <= mem(25);
            when "00111" =>
            x <= mem(24);
            when "01000" =>
            x <= mem(23);
            when "01001" =>
            x <= mem(22);
            when "01010" =>
            x <= mem(21);
            when "01011" =>
            x <= mem(20);
            when "01100" =>
            x <= mem(19);
            when "01101" =>
            x <= mem(18);
            when "01110" =>
            x <= mem(17);
            when "01111" =>
            x <= mem(16);
            when "10000" =>
            x <= mem(15);
            when "10001" =>
            x <= mem(14);
            when "10010" =>
            x <= mem(13);
            when "10011" =>
            x <= mem(12);
            when "10100" =>
            x <= mem(11);
            when "10101" =>
            x <= mem(10);
            when "10110" =>
            x <= mem(9);
            when "10111" =>
            x <= mem(8);
            when "11000" =>
            x <= mem(7);
            when "11001" =>
            x <= mem(6);
            when "11010" =>
            x <= mem(5);
            when "11011" =>
            x <= mem(4);
            when "11100" =>
            x <= mem(3);
            when "11101" =>
            x <= mem(2);
            when "11110" =>
            x <= mem(1);
            when others =>
            x <= mem(0);
            end case;
    end process;

    wplus : process (wup, wnum)
    variable wtemp : std_logic_vector (4 downto 0);
    begin
    if (wup = '1') then
    wtemp := wnum;
    wn <= std_logic_vector(unsigned(wtemp) + to_unsigned(1,2));
    else
    wtemp := wnum;
    wn <= wtemp;
    end if;
    end process;

    bplus : process (bup, bnum)
    variable btemp : std_logic_vector (1 downto 0);
    begin
    if (bup = '1') then
    btemp := bnum;
    bn <= std_logic_vector(unsigned(btemp) + to_unsigned(1,2));
    else
    btemp := bnum;
    bn <= btemp;
    end if;
    end process;

    --komparatory bajtów
    c8: process (in8, x8, y8, compare8)
    begin
        if (in8 = '1') then
            compare8(7) <= x8(7) xor y8(7);
            compare8(6) <= x8(6) xor y8(6);
            compare8(5) <= x8(5) xor y8(5);
            compare8(4) <= x8(4) xor y8(4);
            compare8(3) <= x8(3) xor y8(3);
            compare8(2) <= x8(2) xor y8(2);
            compare8(1) <= x8(1) xor y8(1);
            compare8(0) <= x8(0) xor y8(0);
        else
        compare8 <= (others => '1');
        end if;
        --złączenie wszystkich XOR bramką NOR-na wyjściu uzyskujemy informacje czy są takie same bajty czy różne
            out8 <= not (compare8(7) or compare8(6) or compare8(5) or compare8(4) or compare8(3) or compare8(2) or compare8(1) or compare8(0));
    end process;

    --komparatory wyróżników
    c10: process (in10, x10, y10, compare10)
    begin
        if (in10 = '1') then
            compare10(9) <= x10(9) xor y10(9);
            compare10(8) <= x10(8) xor y10(8);
            compare10(7) <= x10(7) xor y10(7);
            compare10(6) <= x10(6) xor y10(6);
            compare10(5) <= x10(5) xor y10(5);
            compare10(4) <= x10(4) xor y10(4);
            compare10(3) <= x10(3) xor y10(3);
            compare10(2) <= x10(2) xor y10(2);
            compare10(1) <= x10(1) xor y10(1);
            compare10(0) <= x10(0) xor y10(0);
        else
        compare10 <= (others => '1');
        end if;
        --złączenie wszystkich XOR bramką NOR-na wyjściu uzyskujemy informacje czy są takie same bajty czy różne
        out10 <= not (compare10(9) or compare10(8) or compare10(7) or compare10(6) or compare10(5) or compare10(4) or compare10(3) or compare10(2) or compare10(1) or compare10(0));

    end process;

    clock: process (rst,clk, wn, bn, fund)
   begin
    if (rst = '1') then
        state <= search_wyr;
        wnum <= "00000";
        bnum <= "00";
        fn <= "10";
    elsif (clk'event and clk = '1') then
    state <= next_state;
        wnum <= wn;
        bnum <= bn;
        fn <= fund;
        end if;
    end process;
end architecture porownaj;