package BACK

import chisel3._
import chisel3.util._


//work in 100MHZ
class CDRInIO extends Bundle{
  val axis = Decoupled(new AXIS_Bundle(8))
  val serDat = Input(Bool())

  val initEncryptor = Flipped(Valid(UInt(128.W)))
}


abstract class CDRInBase extends Module{


  val io: CDRInIO = IO(new CDRInIO)

  val encryptor = Module(new Encryptor)
  encryptor.io.init := io.initEncryptor
  encryptor.io.op.ready := io.axis.fire

  val syncSerDat = Wire(Bool())
}

trait CDRInOverSample{ this: CDRInBase =>
  val overCLK = IO(Input(Bool()))
  val sampleRate: Int = 4
  require(sampleRate >= 4)

  val sampleReg = withClockAndReset(overCLK.asClock, reset.asBool){ ShiftRegisters( RegNext(io.serDat), sampleRate ) }

  val arbCnt  = withClockAndReset(overCLK.asClock, reset.asBool){ RegInit("b00000001".U(sampleRate.W)) }
  arbCnt := Cat( arbCnt(sampleRate-2,0), arbCnt.extract(sampleRate-1) )
  val arbLock = withClockAndReset(overCLK.asClock, reset.asBool){ Reg(UInt( sampleRate.W )) }
  when( sampleReg(0) ^ sampleReg(1) ){
    arbLock := arbCnt
  }

  val asyncSerDat = withClockAndReset(overCLK.asClock, reset.asBool){ RegNext(
    Mux1H(
      (for { i <- 0 until sampleRate; j <- 0 until sampleRate } yield {
        //跳变沿到来锁定的位置        锁定拍当前所在的位置          选择锁定拍后一拍的值认为是正确值
        ((arbLock === (1.U << i)) & (arbCnt === (1.U << j))) -> sampleReg((sampleRate - 1 - i + j) % sampleRate)
      })
    )
  )}


  syncSerDat := ShiftRegister( asyncSerDat, 2 )

}

trait CDRInMultiSample{ this: CDRInBase =>
  
  val clkNum: Int = 8
  require(clkNum >= 4)

  //multiCLK 需要按照超前相位接线，即0为最后到达，1次后
  val multiCLK = IO(Input(Vec(clkNum, Bool())))

  // val sampleReg = withClockAndReset(io.overCLK.asClock, reset.asBool){ ShiftRegisters( RegNext(io.serDat), sampleRate ) }
  val sampleReg = for( i <- 0 until clkNum ) yield {
    withClockAndReset(multiCLK(i).asClock, reset.asBool){ ShiftRegister( io.serDat, 2 ) }
  }

  // val arbCnt  = withClockAndReset(io.overCLK.asClock, reset.asBool){ RegInit("b00000001".U(sampleRate.W)) }
  // arbCnt := Cat( arbCnt(sampleRate-2,0), arbCnt.extract(sampleRate-1) )
  val arbCnt = RegInit("b1".U(clkNum.W))
  arbCnt := Cat( arbCnt(clkNum-2,0), arbCnt.extract(clkNum-1) )

  // val arbLock = withClockAndReset(io.overCLK.asClock, reset.asBool){ Reg(UInt( sampleRate.W )) }
  // when( sampleReg(0) ^ sampleReg(1) ){
  //   arbLock := arbCnt
  // }
  val arbLock = Reg(UInt( clkNum.W ))
  when( sampleReg(0) ^ sampleReg(1) ){
    arbLock := arbCnt
  }


  // val asyncSerDat = withClockAndReset(io.overCLK.asClock, reset.asBool){ RegNext(
  //   Mux1H(
  //     (for { i <- 0 until sampleRate; j <- 0 until sampleRate } yield {
  //       //跳变沿到来锁定的位置        锁定拍当前所在的位置          选择锁定拍后一拍的值认为是正确值
  //       ((arbLock === (1.U << i)) & (arbCnt === (1.U << j))) -> sampleReg((sampleRate - 1 - i + j) % sampleRate)
  //     })
  //   )
  // )}

  val asyncSerDat = 
    Mux1H(
      (for { i <- 0 until clkNum; j <- 0 until clkNum } yield {
        //跳变沿到来锁定的位置        锁定拍当前所在的位置          选择锁定拍后一拍的值认为是正确值
        ((arbLock === (1.U << i)) & (arbCnt === (1.U << j))) -> sampleReg((clkNum - 1 - i + j) % clkNum)
      })
    )



  // val syncSerDat = ShiftRegister( asyncSerDat, 2 )
  syncSerDat := ShiftRegister( asyncSerDat, 2 )

}



trait CDRInAxis{ this: CDRInBase =>

  def HeaderByte: Int = 4

  val ETH_PRE = "b1100010001".U(10.W)
  val ETH_SFD = "b0110100111".U(10.W)

  val STATE_IDLE = 0.U
  val STATE_HEADER = 1.U
  val STATE_PAYLOAD = 2.U

  val stateNext = Wire(UInt(2.W))
  val stateCurr = RegNext( stateNext, STATE_IDLE )

  val bitCnt = Reg(UInt(4.W))
  val byteCnt = RegInit(0.U((12+1).W))

  val checkSFD = RegInit( 0.U(20.W) ); checkSFD := Cat( checkSFD(18,0), syncSerDat )

  val shiftData = Dualb4b5Decoder(checkSFD(9,0))

  val payloadLen = RegInit(0.U(12.W))
  when( byteCnt === 0.U & bitCnt === 9.U & stateCurr === STATE_HEADER ){
    payloadLen := Cat( shiftData ^ Mux( encryptor.io.op.valid, encryptor.io.op.bits, 0.U ), 0.U(4.W) )
  } .elsewhen( byteCnt === 1.U & bitCnt === 9.U & stateCurr === STATE_HEADER ){
    payloadLen := Cat( payloadLen(11,4), shiftData(7,4) ^ Mux( encryptor.io.op.valid, encryptor.io.op.bits(7,4), 0.U ) )
  }
  
  stateNext := 
    Mux1H(Seq(
      (stateCurr === STATE_IDLE)    -> ( Mux( checkSFD === Cat(ETH_PRE , ETH_SFD), STATE_HEADER, STATE_IDLE )), //IDLE
      (stateCurr === STATE_HEADER)  -> ( Mux( (byteCnt === (HeaderByte-1).U)   & (bitCnt === 9.U), STATE_PAYLOAD, STATE_HEADER ) ),
      (stateCurr === STATE_PAYLOAD) -> ( Mux( (byteCnt === (payloadLen + (4 - 1).U)  ) & (bitCnt === 9.U), STATE_IDLE, STATE_PAYLOAD  )), // PAYLOAD
    ))                                                                  //crc





  when( stateCurr === STATE_IDLE & ( checkSFD === Cat(ETH_PRE, ETH_SFD) ) ){ //first align
    bitCnt := 0.U
  } .otherwise{
    when( bitCnt === 9.U ){
      bitCnt := 0.U
    } .otherwise{
      bitCnt := bitCnt + 1.U
    }
  }

  when( stateCurr === STATE_IDLE & ( checkSFD === Cat(ETH_PRE, ETH_SFD) ) ){ //first align
    byteCnt := 0.U
  } .elsewhen( bitCnt === 9.U ){
    when( stateCurr === STATE_HEADER ){
      byteCnt := Mux( byteCnt =/= (HeaderByte-1).U, byteCnt + 1.U, 0.U )
      assert( byteCnt <= (HeaderByte-1).U )
    } .elsewhen( stateCurr === STATE_PAYLOAD ){
      byteCnt := Mux( byteCnt =/= (payloadLen+ (4-1).U), byteCnt + 1.U, 0.U )
      assert( byteCnt <= ( payloadLen+ (4-1).U ) )
    }
  }





  val axis_valid = RegInit(false.B)
  val axis_tdata = RegEnable( shiftData ^ Mux( encryptor.io.op.valid, encryptor.io.op.bits, 0.U ), bitCnt === 9.U & ( stateCurr === STATE_HEADER | stateCurr === STATE_PAYLOAD ) )
  val axis_tuser = false.B
  val axis_tlast = RegNext( stateCurr === STATE_PAYLOAD & stateNext === STATE_IDLE, false.B )

  io.axis.valid := axis_valid
  io.axis.bits.tdata := axis_tdata
  io.axis.bits.tuser := axis_tuser
  io.axis.bits.tlast := axis_tlast


  when( io.axis.fire ){
    axis_valid := false.B
  } .elsewhen( bitCnt === 9.U & ( stateCurr === STATE_HEADER | stateCurr === STATE_PAYLOAD ) ){
    axis_valid := true.B
  }

}


class CDRIn extends CDRInBase 
with CDRInAxis