package ts

import (
	"fmt"
	"io"
	"io/ioutil"
)

func ReadUInt(r io.Reader, n int) (res uint, err error) {
	var b [4]byte
	if _, err = r.Read(b[0:n]); err != nil {
		return
	}
	for i := 0; i < n; i++ {
		res <<= 8
		res |= uint(b[i])
	}
	return
}

func ReadDummy(r io.Reader, n int) (err error) {
	_, err = io.CopyN(ioutil.Discard, r, int64(n))
	return
}

func ReadUInt64(r io.Reader, n int) (res uint64, err error) {
	var res32 uint
	if n > 4 {
		if res32, err = ReadUInt(r, n-4); err != nil {
			return
		}
		res |= uint64(res32) << 32
		n = 4
	}
	if res32, err = ReadUInt(r, n); err != nil {
		return
	}
	res |= uint64(res32)
	return
}

func ReadTSHeader(r io.Reader) (self TSHeader, err error) {
	var flags uint

	// sync(8)
	// transport_error_indicator(1)
	// payload_unit_start_indicator(1)
	// transport_priority(1)
	// pid(13)
	// Scrambling control(2)
	// Adaptation field flag(1)
	// Continuity counter(4)
	if flags, err = ReadUInt(r, 4); err != nil {
		return
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "ts: flags %s\n", FieldsDumper{
			Fields: []struct {
				Length int
				Desc   string
			}{
				{8, "sync"},
				{1, "transport_error_indicator"},
				{1, "payload_unit_start_indicator"},
				{1, "transport_priority"},
				{13, "pid"},
				{2, "scrambling_control"},
				{1, "adaptation_field_flag"},
				{1, "payload_flag"},
				{4, "continuity_counter"},
			},
			Val:    flags,
			Length: 32,
		})
	}

	if flags&0x400000 != 0 {
		//  When set to '1' it indicates that this TS packet contains the first PES packet.
		self.PayloadUnitStart = true
	}

	if (flags&0xff000000)>>24 != 0x47 {
		err = fmt.Errorf("invalid sync")
		return
	}

	self.PID = (flags & 0x1fff00) >> 8
	self.ContinuityCounter = flags & 0xf

	if flags&0x20 != 0 {
		var flags, length uint
		if length, err = ReadUInt(r, 1); err != nil {
			return
		}
		if length > 0 {
			lr := &io.LimitedReader{R: r, N: int64(length)}
			if flags, err = ReadUInt(lr, 1); err != nil {
				return
			}

			if DebugReader {
				fmt.Fprintf(DebugOutput, "ts: ext_flags %s\n", FieldsDumper{
					Fields: []struct {
						Length int
						Desc   string
					}{
						{1, "discontinuity_indicator"},
						{1, "random_access_indicator"},
						{1, "elementary_stream_priority_indicator"},
						{1, "pcr_flag"},
						{1, "opcr_flag"},
						{1, "splicing_point_flag"},
						{1, "transport_private_data_flag"},
						{1, "adaptation_field_extension_flag"},
					},
					Val:    flags,
					Length: 8,
				})
			}

			// random_access_indicator
			if flags&0x40 != 0 {
				self.RandomAccessIndicator = true
			}

			// PCR
			if flags&0x10 != 0 {
				var v uint64
				if v, err = ReadUInt64(lr, 6); err != nil {
					return
				}
				// clock is 27MHz
				self.PCR = UIntToPCR(v)
				if DebugReader {
					fmt.Fprintf(DebugOutput, "ts: PCR %d %f\n", self.PCR, float32(self.PCR)/PCR_HZ)
				}
			}

			// OPCR
			if flags&0x08 != 0 {
				var v uint64
				if v, err = ReadUInt64(lr, 6); err != nil {
					return
				}
				self.OPCR = UIntToPCR(v)
			}

			// Splice countdown
			if flags&0x04 != 0 {
				if _, err = ReadUInt(lr, 1); err != nil {
					return
				}
			}

			// Transport private data
			if flags&0x02 != 0 {
				var length uint
				if length, err = ReadUInt(lr, 1); err != nil {
					return
				}

				b := make([]byte, length)
				if _, err = lr.Read(b); err != nil {
					return
				}
			}

			// Adaptation extension
			if lr.N > 0 {
				if DebugReader {
					// rubish
					fmt.Fprintln(DebugOutput, "ts: skip", lr.N)
				}

				if err = ReadDummy(lr, int(lr.N)); err != nil {
					return
				}
			}
		}
	}

	return
}

func ReadTSPacket(r io.Reader, data []byte) (self TSHeader, n int, err error) {
	lr := &io.LimitedReader{R: r, N: 188}
	if self, err = ReadTSHeader(lr); err != nil {
		return
	}
	if DebugReader {
		fmt.Fprintln(DebugOutput, "ts: data len", lr.N)
	}
	if n, err = lr.Read(data[:lr.N]); err != nil {
		return
	}
	return
}

func ReadPSI(r io.Reader) (self PSI, lr *io.LimitedReader, cr *Crc32Reader, err error) {
	var flags, pointer, length uint

	// pointer field
	if pointer, err = ReadUInt(r, 1); err != nil {
		return
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "psi: pointer=%d\n", pointer)
	}

	if pointer != 0 {
		if err = ReadDummy(r, int(pointer)); err != nil {
			return
		}
	}

	cr = &Crc32Reader{R: r, Crc32: 0xffffffff}

	// table_id
	if self.TableId, err = ReadUInt(cr, 1); err != nil {
		return
	}

	// reserved(4)=0xb
	// section_length(10)
	if flags, err = ReadUInt(cr, 2); err != nil {
		return
	}
	length = flags & 0x3FF

	if DebugReader {
		fmt.Fprintf(DebugOutput, "psi: tableid=%d len=%d\n", self.TableId, length)
	}

	lr = &io.LimitedReader{R: cr, N: int64(length)}

	// Table ID extension(16)
	if self.TableIdExtension, err = ReadUInt(lr, 2); err != nil {
		return
	}

	// resverd(2)=3
	// version(5)
	// Current_next_indicator(1)
	if flags, err = ReadUInt(lr, 1); err != nil {
		return
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "psi: %s\n", FieldsDumper{
			Fields: []struct {
				Length int
				Desc   string
			}{
				{2, "resverd"},
				{5, "version"},
				{1, "current_next_indicator"},
			},
			Val:    flags,
			Length: 8,
		})
	}

	// section_number(8)
	if self.SecNum, err = ReadUInt(lr, 1); err != nil {
		return
	}

	// last_section_number(8)
	if self.LastSecNum, err = ReadUInt(lr, 1); err != nil {
		return
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "psi: table_id=%x table_extension=%x secnum=%x lastsecnum=%x\n",
			self.TableId,
			self.TableIdExtension,
			self.SecNum,
			self.LastSecNum,
		)
	}

	lr.N -= 4
	return
}

func ReadPMT(r io.Reader) (self PMT, err error) {
	readDescs := func(lr *io.LimitedReader) (res []Descriptor, err error) {
		var desc Descriptor
		for lr.N > 0 {
			if desc.Tag, err = ReadUInt(lr, 1); err != nil {
				return
			}
			var length uint
			if length, err = ReadUInt(lr, 1); err != nil {
				return
			}
			desc.Data = make([]byte, length)
			if _, err = lr.Read(desc.Data); err != nil {
				return
			}
			res = append(res, desc)
		}
		return
	}

	var lr *io.LimitedReader
	var cr *Crc32Reader
	//var psi PSI

	if _, lr, cr, err = ReadPSI(r); err != nil {
		return
	}

	var flags, length uint

	// 111(3)
	// PCRPID(13)
	if flags, err = ReadUInt(lr, 2); err != nil {
		return
	}
	self.PCRPID = flags & 0x1fff

	if DebugReader {
		fmt.Fprintf(DebugOutput, "pmt: %s\n", FieldsDumper{
			Fields: []struct {
				Length int
				Desc   string
			}{
				{3, "reserved"},
				{13, "pcrpid"},
			},
			Val:    flags,
			Length: 16,
		})
	}

	// Reserved(4)=0xf
	// Reserved(2)=0x0
	// Program info length(10)
	if flags, err = ReadUInt(lr, 2); err != nil {
		return
	}
	length = flags & 0x3ff

	if DebugReader {
		fmt.Fprintf(DebugOutput, "pmt: ProgramDescriptorsLen=%d\n", length)
	}

	if length > 0 {
		lr := &io.LimitedReader{R: lr, N: int64(length)}
		if self.ProgramDescriptors, err = readDescs(lr); err != nil {
			return
		}
	}

	for lr.N > 0 {
		var info ElementaryStreamInfo
		if info.StreamType, err = ReadUInt(lr, 1); err != nil {
			return
		}

		// Reserved(3)
		// Elementary PID(13)
		if flags, err = ReadUInt(lr, 2); err != nil {
			return
		}
		info.ElementaryPID = flags & 0x1fff

		if DebugReader {
			fmt.Fprintf(DebugOutput, "pmt: info1 %s\n", FieldsDumper{
				Fields: []struct {
					Length int
					Desc   string
				}{
					{3, "reserved"},
					{13, "elementary_pid"},
				},
				Val:    flags,
				Length: 16,
			})
		}

		// Reserved(6)
		// ES Info length(10)
		if flags, err = ReadUInt(lr, 2); err != nil {
			return
		}
		length = flags & 0x3ff

		if DebugReader {
			fmt.Fprintf(DebugOutput, "pmt: info2 %s\n", FieldsDumper{
				Fields: []struct {
					Length int
					Desc   string
				}{
					{6, "reserved"},
					{10, "es_info_length"},
				},
				Val:    flags,
				Length: 16,
			})
		}

		if length > 0 {
			lr := &io.LimitedReader{R: lr, N: int64(length)}
			if info.Descriptors, err = readDescs(lr); err != nil {
				return
			}
		}
		self.ElementaryStreamInfos = append(self.ElementaryStreamInfos, info)
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "pmt: ProgramDescriptors %v\n", self.ProgramDescriptors)
		fmt.Fprintf(DebugOutput, "pmt: ElementaryStreamInfos %v\n", self.ElementaryStreamInfos)
	}

	if err = cr.ReadCrc32UIntAndCheck(); err != nil {
		if DebugReader {
			fmt.Fprintf(DebugOutput, "pmt: %s\n", err)
		}
		return
	}

	return
}

func ReadPAT(r io.Reader) (self PAT, err error) {
	var lr *io.LimitedReader
	var cr *Crc32Reader
	//var psi PSI

	if _, lr, cr, err = ReadPSI(r); err != nil {
		return
	}

	for lr.N > 0 {
		entry := PATEntry{}
		if entry.ProgramNumber, err = ReadUInt(lr, 2); err != nil {
			return
		}
		if entry.ProgramNumber == 0 {
			if entry.NetworkPID, err = ReadUInt(lr, 2); err != nil {
				return
			}
			entry.NetworkPID &= 0x1fff
		} else {
			if entry.ProgramMapPID, err = ReadUInt(lr, 2); err != nil {
				return
			}
			entry.ProgramMapPID &= 0x1fff
		}
		self.Entries = append(self.Entries, entry)
	}

	if err = cr.ReadCrc32UIntAndCheck(); err != nil {
		if DebugReader {
			fmt.Fprintf(DebugOutput, "pat: %s\n", err)
		}
		return
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "pat: %v\n", self)
	}

	return
}

func ReadPESHeader(r io.Reader) (res *PESHeader, err error) {
	var flags, length uint
	self := &PESHeader{}

	// http://dvd.sourceforge.net/dvdinfo/pes-hdr.html

	// start code 000001
	if flags, err = ReadUInt(r, 3); err != nil {
		return
	}
	if flags != 0x000001 {
		err = fmt.Errorf("invalid PES header")
		return
	}

	if self.StreamId, err = ReadUInt(r, 1); err != nil {
		return
	}

	if length, err = ReadUInt(r, 2); err != nil {
		return
	}
	if DebugReader {
		fmt.Fprintf(DebugOutput, "pes: StreamId=%x length=%d\n", self.StreamId, length)
	}

	if length == 0 {
		length = 1 << 31
	}
	lrAll := &io.LimitedReader{R: r, N: int64(length)}
	lr := lrAll

	// 10(2)
	// PES scrambling control(2)
	// PES priority(1)
	// data alignment indicator(1)
	// copyright(1)
	// original or copy(1)
	if _, err = ReadUInt(lr, 1); err != nil {
		return
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "pes: %s\n", FieldsDumper{
			Fields: []struct {
				Length int
				Desc   string
			}{
				{2, "scrambling_control"},
				{1, "priority"},
				{1, "data_alignment_indicator"},
				{1, "copyright"},
				{1, "original_or_copy"},
			},
			Val:    flags,
			Length: 6,
		})
	}

	// PTS DTS flags(2)
	// ESCR flag(1)
	// ES rate flag(1)
	// DSM trick mode flag(1)
	// additional copy info flag(1)
	// PES CRC flag(1)
	// PES extension flag(1)
	if flags, err = ReadUInt(lr, 1); err != nil {
		return
	}

	if DebugReader {
		fmt.Fprintf(DebugOutput, "pes: %s\n", FieldsDumper{
			Fields: []struct {
				Length int
				Desc   string
			}{
				{2, "pts_dts_flags"},
				{1, "escr_flag"},
				{1, "es_rate_flag"},
				{1, "dsm_trick_mode_flag"},
				{1, "additional_copy_info_flag"},
				{1, "pes_crc_flag"},
				{1, "pes_extension_flag"},
			},
			Val:    flags,
			Length: 8,
		})
	}

	// PES header data length(8)
	if length, err = ReadUInt(lr, 1); err != nil {
		return
	}
	lr = &io.LimitedReader{R: lr, N: int64(length)}

	if flags&0x80 != 0 {
		var v uint64
		if v, err = ReadUInt64(lr, 5); err != nil {
			return
		}
		self.PTS = PESUIntToTs(v)

		if DebugReader {
			fmt.Fprintf(DebugOutput, "pes: pts %d %f\n", self.PTS, float32(self.PTS)/float32(PTS_HZ))
		}
	}

	if flags&0x40 != 0 && flags&0x80 != 0 {
		var v uint64
		if v, err = ReadUInt64(lr, 5); err != nil {
			return
		}
		self.DTS = PESUIntToTs(v)
		if DebugReader {
			fmt.Fprintf(DebugOutput, "pes: dts %d %f\n", self.DTS, float32(self.DTS)/float32(PTS_HZ))
		}
	}

	// ESCR flag
	if flags&0x20 != 0 {
		if _, err = ReadUInt64(lr, 6); err != nil {
			return
		}
	}

	// ES rate flag
	if flags&0x10 != 0 {
		if _, err = ReadUInt64(lr, 3); err != nil {
			return
		}
	}

	// additional copy info flag
	if flags&0x04 != 0 {
		if _, err = ReadUInt(lr, 1); err != nil {
			return
		}
	}

	// PES CRC flag
	if flags&0x02 != 0 {
		if _, err = ReadUInt(lr, 2); err != nil {
			return
		}
	}

	// PES extension flag
	if flags&0x01 != 0 {
		var flags uint

		// PES private data flag(1)
		// pack header field flag(1)
		// program packet sequence counter flag(1)
		// P-STD buffer flag(1)
		// 111(3)
		// PES extension flag 2(1)
		if flags, err = ReadUInt(lr, 1); err != nil {
			return
		}

		// PES private data flag(1)
		if flags&0x80 != 0 {
			// if set to 1 16 bytes of user defined data is appended to the header data field
			if err = ReadDummy(lr, 16); err != nil {
				return
			}
		}

		// pack header field flag(1)
		if flags&0x40 != 0 {
			// if set to 1 the 8-bit pack field length value is appended to the header data field
			if err = ReadDummy(lr, 1); err != nil {
				return
			}
		}

		// program packet sequence counter flag(1)
		if flags&0x20 != 0 {
			if err = ReadDummy(lr, 2); err != nil {
				return
			}
		}

		// P-STD buffer flag(1)
		if flags&0x10 != 0 {
			if err = ReadDummy(lr, 2); err != nil {
				return
			}
		}

		// PES extension flag 2(1)
		if flags&0x01 != 0 {
			if err = ReadDummy(lr, 2); err != nil {
				return
			}
		}
	}

	if lr.N > 0 {
		if err = ReadDummy(lr, int(lr.N)); err != nil {
			return
		}
	}

	if lrAll.N < 65536 {
		self.DataLength = uint(lrAll.N)
	}

	res = self
	return
}