func main() {

	N := 2048
	begin := time.Now()
	var ofdm customchips.OFDM
	ofdm.InitializeChip()
	ofdm.NPoint = N

	// fmt.Printf("\n OFDM = %v", ofdm)
	/// Input
	inCHA := gocomm.NewComplex128AChannel()
	// inCH := gocomm.NewComplex128Channel()
	var dataArray gocomm.SComplex128AObj

	x := sources.RandNCVec(N, 1)
	dataArray.Ch = x
	dataArray.MaxExpected = 1
	inCHA <- dataArray
	go ofdm.Ifft(inCHA)
	go ofdm.Fft(ofdm.PinByName("outputPin0").Channel.(gocomm.Complex128AChannel))
	outCHA := ofdm.PinByName("outputPin1").Channel.(gocomm.Complex128AChannel)
	data := <-outCHA
	/// Analyse
	fmt.Printf("\nX=%f", x[0:16])
	fmt.Printf("\nOutput=%f", data.Ch[0:16])
	// xcap := dsp.ExtFFT_C(data.Ch, N)
	// fmt.Printf("\nXcap=%f", xcap[0:16])

	fmt.Printf("\nTime Elapsed : %v\n", time.Since(begin))
}

func (cdma *CDMA) Spread(chInway gocomm.Complex128Channel, OutCH gocomm.Complex128AChannel) {

	indata := <-chInway
	insymbol := indata.Ch
	spcode := cdma.SpreadSequence
	var result = make([]complex128, len(spcode))
	for i := 0; i < len(spcode); i++ {
		result[i] = insymbol * spcode[i]
	}
	var chdataOut gocomm.SComplex128AObj
	chdataOut.Ch = result
	chdataOut.MaxExpected = indata.MaxExpected / len(spcode)
	// chdataOut.MaxExpected = int(math.Floor(float64(indata.MaxExpected) / float64(len(spcode))))
	OutCH <- chdataOut
}

func (m *MPChannel) ChannelFn(sample gocomm.SComplex128Obj) (result gocomm.SComplex128Obj) {
	/// Read your data from Input channel(s) [inputPin0]
	/// And write it to OutputChannels  [outputPin0]
	// fmt.Printf("\n Channel Param %#v  \n input = %v", m.ChannelParam, sample)

	if m.Ts == -1 {

		m.Coeff.Resize(m.pdp.Size())
		for i := 0; i < m.pdp.Size(); i++ {
			m.Coeff[i] = sources.RandNC(m.pdp[i])
		}
		if m.FeedbackCH != nil {
			var chdata gocomm.SComplex128AObj
			chdata.Ch = m.Coeff
			chdata.TimeStamp = m.TimeStamp
			chdata.MaxExpected = sample.MaxExpected
			chdata.Ts = m.Ts
			fmt.Printf("\n FAST IID generated for [email protected]%v with %[email protected]%v", sample.TimeStamp, m.TimeStamp, cmplx.Abs(m.Coeff[0])*cmplx.Abs(m.Coeff[0]))
			m.FeedbackCH <- chdata
		}

	} else {

		m.updateCoeff(sample.TimeStamp)

	}
	if m.FilterMemory.Size() != m.Coeff.Size() {
		m.FilterMemory.Resize(m.Coeff.Size())
	}

	result = sample /// Carefull if not same ChType
	// m.TimeStamp = sample.TimeStamp
	m.FilterMemory = m.FilterMemory.ShiftLeft(sample.Ch)

	//dummy := vlib.ElemMultC(m.Coeff, vlib.Conj(m.Coeff))
	foutput := vlib.DotC(m.Coeff, m.FilterMemory)
	// fmt.Printf("\n CHANNEL @%v: I/P %v - Gain : %v  : O/p : %v", sample.TimeStamp, sample.Ch, cmplx.Abs(m.Coeff[0])*cmplx.Abs(m.Coeff[0]), foutput)
	result.Ch = foutput
	result.Message = sample.Message + " Filter"
	result.Ts = sample.Ts
	result.TimeStamp = sample.TimeStamp
	result.MaxExpected = sample.MaxExpected
	// fmt.Printf("\n I/O (hn =%v) : %#v --> %#v", m.Coeff, sample, result)
	return result

}

func (cdma *CDMA) SpreadBlock(expectedInputSymbols int, chInway gocomm.Complex128Channel, OutCH gocomm.Complex128AChannel) {

	spcode := cdma.SpreadSequence
	if len(spcode) == 0 {
		panic("Spreading Code not Set")
	}
	for i := 0; i < expectedInputSymbols; i++ {

		indata := <-chInway
		insymbol := indata.Ch
		var result = make([]complex128, len(spcode))
		for i := 0; i < len(spcode); i++ {
			result[i] = insymbol * spcode[i]
		}
		var chdataOut gocomm.SComplex128AObj
		chdataOut.Ch = result
		OutCH <- chdataOut
	}
	close(chInway)
}

func (m *OFDM) Fft(inputPin1 gocomm.Complex128AChannel) {
	/// Read your data from Input channel(s) [inputPin1]
	/// And write it to OutputChannels  [outputPin1]

	outputPin1 := m.Pins["outputPin1"].Channel.(gocomm.Complex128AChannel)
	iters := 1
	for i := 0; i < iters; i++ {
		chData := <-inputPin1
		iters = chData.MaxExpected
		tsamples := chData.Ch
		/// Do process here with chData

		var outData gocomm.SComplex128AObj
		outData.Ch = dsp.ExtFFT_C(tsamples, m.NPoint)

		/// copy meta
		outData.MaxExpected = chData.MaxExpected
		outData.Ts = chData.Ts
		outData.TimeStamp = chData.TimeStamp
		outData.Message = chData.Message

		outputPin1 <- outData
		iters = chData.MaxExpected
	}

}

func (m *MPChannel) updateCoeff(timestamp float64) {
	/// first time
	generated := false
	if m.TimeStamp == -1 {
		m.Coeff.Resize(m.pdp.Size())
		for i := 0; i < m.pdp.Size(); i++ {
			m.Coeff[i] = sources.RandNC(m.pdp[i])
		}
		generated = true
		m.TimeStamp = 0 /// Unusuall if inbetween the MPchannel timestamp has got RESET !!

	} else {

		/// Existing channel-coeff is valid till m.Timestamp+m.TS,
		valid := timestamp < (m.TimeStamp + m.Ts)

		if !valid {
			/// TRIGGER NEW COEFF
			m.Coeff = vlib.NewVectorC(m.pdp.Size())
			for i := 0; i < m.pdp.Size(); i++ {
				m.Coeff[i] = sources.RandNC(m.pdp[i])
			}

			m.TimeStamp = timestamp
			generated = true
		}

	}

	/// Write new coeff to feedback channel if new was generated
	if m.FeedbackCH != nil && generated {
		var chdata gocomm.SComplex128AObj
		chdata.Ch = m.Coeff
		chdata.TimeStamp = m.TimeStamp
		chdata.Ts = m.Ts
		// fmt.Printf("\n CH:GENERATED @ %v with Coeff : %v, Gain : %v ", timestamp, m.Coeff[0], cmplx.Abs(m.Coeff[0])*cmplx.Abs(m.Coeff[0]))
		m.FeedbackCH <- chdata
	}

}

func (m *MPChannel) Channel(inputPin0 gocomm.Complex128Channel) {
	/// Read your data from Input channel(s) [inputPin0]
	/// And write it to OutputChannels  [outputPin0]

	outputPin0 := chipset.ToComplexCH(m.Pins["outputPin0"])
	var IdealChObj gocomm.SComplex128AObj

	iters := 1
	for i := 0; i < iters; i++ {
		chData := <-inputPin0
		iters = chData.MaxExpected
		/// Do process here with chData

		outData := m.ChannelFn(chData)
		/// coeff attempt to send
		IdealChObj.Ch = m.Coeff
		IdealChObj.Ts = chData.Ts
		IdealChObj.TimeStamp = chData.TimeStamp
		IdealChObj.Message = chData.Message
		IdealChObj.MaxExpected = chData.MaxExpected
		//fmt.Printf("\n Want to broadcast %#v to %#v", IdealChObj, coeffPin)
		///

		// select {
		// case coeffPin <- IdealChObj:
		// 	// fmt.Printf("\n%f : sent message %v", IdealChObj.TimeStamp, IdealChObj.Ch)
		// default:
		// 	// fmt.Printf("\n%f: no message sent", IdealChObj.TimeStamp)
		// }
		outputPin0 <- outData
	}

}