/*
NAME
  lex_test.go

DESCRIPTION
  lex_test.go provides tests to check validity of the Lexer found in lex.go.

AUTHORS
  Saxon A. Nelson-Milton <saxon@ausocean.org>

LICENSE
  Copyright (C) 2019 the Australian Ocean Lab (AusOcean).

  It is free software: you can redistribute it and/or modify them
  under the terms of the GNU General Public License as published by the
  Free Software Foundation, either version 3 of the License, or (at your
  option) any later version.

  It is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 for more details.

  You should have received a copy of the GNU General Public License
  in gpl.txt.  If not, see http://www.gnu.org/licenses.
*/

package h265

import (
	"io"
	"testing"

	"bitbucket.org/ausocean/av/protocol/rtp"
)

type rtpReader struct {
	pkts []rtp.Pkt
	idx  int
}

func (r *rtpReader) Read(p []byte) (int, error) {
	if r.idx == len(r.pkts) {
		return 0, io.EOF
	}
	b := r.pkts[r.idx].Bytes(nil)
	copy(p, r.pkts[r.idx].Bytes(nil))
	r.idx++
	return len(b), nil
}

type destination [][]byte

func (d *destination) Write(p []byte) (int, error) {
	t := make([]byte, len(p))
	copy(t, p)
	*d = append([][]byte(*d), t)
	return len(p), nil
}

func TestLexNo(t *testing.T) {
	const rtpVer = 2

	packets := []rtp.Pkt{
		// Singla NAL
		rtp.Pkt{
			V: rtpVer,
			Payload: []byte{
				0x40, 0x00, // NAL header (type=32 VPS).
				0x01, 0x02, 0x03, 0x04, // NAL Data.
			},
		},
		// Fragmentation (start packet).
		rtp.Pkt{
			V: rtpVer,
			Payload: []byte{
				0x62, 0x00, // NAL header (type49).
				0x80,             // FU header.
				0x01, 0x02, 0x03, // FU payload.
			},
		},

		// Fragmentation (middle packet)
		rtp.Pkt{
			V: rtpVer,
			Payload: []byte{
				0x62, 0x00, // NAL header (type 49).
				0x00,             // FU header.
				0x04, 0x05, 0x06, // FU payload.
			},
		},

		// Fragmentation (end packet)
		rtp.Pkt{
			V: rtpVer,
			Payload: []byte{
				0x62, 0x00, // NAL header (type 49).
				0x40,             // FU header.
				0x07, 0x08, 0x09, // FU payload
			},
		},

		// Aggregation.
		// Consider last packet of access unit - M true
		rtp.Pkt{
			V: rtpVer,
			M: true,
			Payload: []byte{
				0x60, 0x00, // NAL header (type 49).
				0x00, 0x04, // NAL 1 size.
				0x01, 0x02, 0x03, 0x04, // NAL 1 data.
				0x00, 0x04, // NAL 2 size.
				0x01, 0x02, 0x03, 0x04, // NAL 2 data.
			},
		},

		// Singla NAL
		rtp.Pkt{
			V: rtpVer,
			Payload: []byte{
				0x40, 0x00, // NAL header (type=32 VPS).
				0x01, 0x02, 0x03, 0x04, // NAL data.
			},
		},

		// Singla NAL
		rtp.Pkt{
			V: rtpVer,
			M: true,
			Payload: []byte{
				0x40, 0x00, // NAL header (type=32 VPS).
				0x01, 0x02, 0x03, 0x04, // NAL data.
			},
		},
	}

	expect := [][]byte{
		// First access unit.
		{
			// NAL 1
			0x00, 0x00, 0x00, 0x01, // Start code.
			0x40, 0x00, // NAL header (type=32 VPS).
			0x01, 0x02, 0x03, 0x04, // NAL data.

			// NAL 2
			0x00, 0x00, 0x00, 0x01, // Start code.
			0x01, 0x02, 0x03, // FU payload.
			0x04, 0x05, 0x06, // FU payload.
			0x07, 0x08, 0x09, // FU payload.

			// NAL 3
			0x00, 0x00, 0x00, 0x01, // Start code.
			0x01, 0x02, 0x03, 0x04, // NAL data.

			// NAL 4
			0x00, 0x00, 0x00, 0x01, // Start code.
			0x01, 0x02, 0x03, 0x04, // NAL 2 data
		},
		// Second access unit.
		{
			// NAL 1
			0x00, 0x00, 0x00, 0x01, // Start code.
			0x40, 0x00, // NAL header (type=32 VPS).
			0x01, 0x02, 0x03, 0x04, // Data.

			// NAL 2
			0x00, 0x00, 0x00, 0x01, // Start code.
			0x40, 0x00, // NAL header (type=32 VPS).
			0x01, 0x02, 0x03, 0x04, // Data.
		},
	}

	r := &rtpReader{pkts: packets}
	d := &destination{}
	l := Lexer{UsingDON: false}
	err := l.Lex(d, r, 0)
	if err != nil {
		t.Fatalf("error lexing: %v\n", err)
	}

	for i, au := range expect {
		for j, b := range au {
			if b != [][]byte(*d)[i][j] {
				t.Fatalf("did not get expected data.\nGot: %v\nWant: %v\n", d, expect)
			}
		}
	}
}