`timescale 1ns/1ps

module lcbbc
  #(parameter N = 16
    )
  (input clk,
   input          rst, //positive reset
   input [N-1:0]  n,
   input [N-1:0]  min_hd,
   input          start,
   output reg [N-1:0] codes
   );


  localparam [2:0]
    IDLE = 0,
    CALC_HD = 1,
    CLOCK_CALC_HD = 2,
    FIND_CODE = 3,
    CLOCK_FIND_CODE = 4,
    OUTPUT_CODE = 5,
    CLOCK_OUTPUT_CODE = 6;



  reg [2:0]           state, nxt_state;
  reg [N-1:0]         counterl, nxt_counterl;
  reg [N-1:0]         counterh, nxt_counterh;
  reg [N-1:0]         cand_counter, nxt_cand_counter;
  reg [N-1:0]         new_cand_counter, nxt_new_cand_counter;
  reg [N-1:0]         pivot_counter, nxt_pivot_counter;
  reg [N-1:0]         chain_counter, nxt_chain_counter;
  reg                 lock, nxt_lock;
  reg [N-1:0]         nxt_codes;

  //sequential block
  always @(posedge clk)
    if(rst)
      begin
        state         <= #1 IDLE;
        counterl      <= #1 2**N-1;
        counterh      <= #1 0;
        cand_counter  <= #1 0;
        pivot_counter <= #1 0;
        chain_counter <= #1 0;
        lock          <= #1 0;
        new_cand_counter <= #1 0;
        codes            <= #1 0;
      end
    else
      begin
        state         <= #1 nxt_state;
        counterl      <= #1 nxt_counterl;
        counterh      <= #1 nxt_counterh;
        cand_counter  <= #1 nxt_cand_counter;
        pivot_counter <= #1 nxt_pivot_counter;
        chain_counter <= #1 nxt_chain_counter;
        lock          <= #1 nxt_lock;
        new_cand_counter <= #1 nxt_new_cand_counter;
        codes            <= #1 nxt_codes;
      end



  reg [N-1:0]         HD [0:2**N-1];
  reg [N-1:0]         summation;
  reg [N-1:0]         candidates[0:2**N-1];
  reg [N-1:0]         new_candidates[0:2**N-1]; //equivalent of next_candidates
  reg [N-1:0]         candidate;
  reg [N-1:0]         chain[0:2**N-1];
  reg [N-1:0]         i;

  //assign  codes = results[0] ;

  //Finite STATE MACHINE
  always@*
    begin
      //defaults
      nxt_state         = state;
      nxt_counterl      = counterl;
      nxt_counterh      = counterh;
      nxt_cand_counter  = cand_counter;
      nxt_pivot_counter = pivot_counter;
      nxt_chain_counter = chain_counter;
      nxt_lock          = lock;
      nxt_new_cand_counter = new_cand_counter;
      nxt_codes         = codes;

      case(state)
        IDLE:
          begin
            if(start)
              nxt_state = CALC_HD;
          end

        CALC_HD:
          begin
            summation = sum(counterl ^ counterh); //function call
            if( summation >= min_hd )
                begin
                  HD[counterl] = 1;
                  candidates[cand_counter] = counterl;
                  nxt_cand_counter = cand_counter + 1;
                  nxt_pivot_counter = nxt_cand_counter;
                end
            else
              HD[counterl] = 0;

            nxt_counterl = counterl - 1;
            if(counterl == 0)
              begin
                nxt_counterh = counterh + 1;
                //$display($time,": In CALC_HD: chain_counter=%2d, counterh=%2d\n",chain_counter,counterh);
                chain[chain_counter] = counterh;
                nxt_chain_counter = chain_counter + 1;
                nxt_state = FIND_CODE;
              end
            else
              nxt_state = CLOCK_CALC_HD;
          end // case: CALC_HD

        CLOCK_CALC_HD:
          begin
            nxt_state = CALC_HD;
          end

        FIND_CODE:
          begin
            if( pivot_counter > 1)
              begin
                if(! lock )
                  begin
                    candidate = candidates[pivot_counter-1];  //since pivot counter exceeds by 1
                    nxt_lock = 1;
                  end

                if( cand_counter > 1 )
                  begin
                    summation = sum(candidate ^ candidates[cand_counter - 2]); // e.g 3 ^ 5
                    if (summation >= min_hd)
                      begin
                        new_candidates[new_cand_counter] = candidates[cand_counter -2];
                        nxt_new_cand_counter = new_cand_counter + 1;
                      end

                    nxt_cand_counter = cand_counter - 1;
                  end // if ( cand_counter > 1 )


                else
                  begin
                    for(i=0; i < new_cand_counter; i=i+1)
                      candidates[i] = new_candidates[i];
                    nxt_cand_counter = new_cand_counter;
                    chain[chain_counter] = candidate;
                    //$display($time,": chain[%2d]=%2d\n",chain_counter,chain[chain_counter]);
                    nxt_chain_counter = chain_counter + 1;
                    nxt_pivot_counter = new_cand_counter;
                    nxt_new_cand_counter = 0;
                    nxt_lock = 0;
                  end // else: !if(! cand_counter )

                nxt_state = CLOCK_FIND_CODE;

              end // if ( pivot_counter > 1)


            else
              begin
                //$display($time,": chain_counter=%2d,candidates[0]=%2d\n",chain_counter,candidates[0]);
                chain[chain_counter] = candidates[0]; //put the last one
                nxt_pivot_counter = 0;
                nxt_cand_counter = 0;
                nxt_new_cand_counter = 0;
                //$display($time,": Before going to OUTPUT_CODES, chain_counter=%2d\n",chain_counter);
                nxt_state = OUTPUT_CODE;
              end // else: !if( pivot_counter > 1)

          end // case: FIND_CODE

        CLOCK_FIND_CODE:
          begin
            nxt_state = FIND_CODE;
          end

        OUTPUT_CODE:
          begin
            //$display($time,": In the OUTPUT_CODES, chain_counter=%2d\n",chain_counter);
            if( chain_counter != 0 )
              begin
                nxt_codes = chain[chain_counter];
                //$display($time,": In output: chain_counter=%2d, chain[%2d]=%2d\n",chain_counter, chain_counter,chain[chain_counter]);
                nxt_chain_counter = chain_counter - 1;
                nxt_state = CLOCK_OUTPUT_CODE;
              end
            else
              begin
                //$display($time,": going  to CALC_HD\n");
                nxt_codes = chain[chain_counter];
                nxt_counterl = 2**N-1;
                nxt_state = CALC_HD;
              end
          end // case: OUTPUT_CODE


        CLOCK_OUTPUT_CODE:
          begin
            nxt_state = OUTPUT_CODE;
          end

      endcase // case (state)

    end // always@ *




  function [N-1:0] sum(input [N-1:0] input_vector);
    integer       k;
    reg [N-1:0]   temp;

    begin
      temp = 0;
      for(k=0; k < N; k=k+1)
        begin
          temp = temp + input_vector[k];
        end
      sum = temp;
    end

  endfunction // sum





endmodule // lcbbc