import struct
from collections import OrderedDict
import sys

"""
   char         Available;         // flag if entry is available for use
   char         Used;            // flag if entry is used
   char         Skip;            // flag if entry is to be skipped by +/-
   char         Source;            // signal source, see enumeration below
   char         Signal;            // signal type, see enumeration below
   char         Modulation;         // modulation, see enumeration below
   char         Locked;            // channel locked (0=open, 1=locked)
   char         Unknown7;         //*14 | 8
   char         Tuned;            //*0 | 1
   short         Number;            //*customized channel number
   char         Unknown11;         //*-1 | 14
   long         Unknown12;         //*0
   short         Preset;            //*pre-assigned channel number
   unsigned short   Length;            // channel name length (in BYTES!)
   unsigned short   Name[6];         // big-endian Unicode characters
   float         Frequency;         // frequency in MHz with fractions
   char         Unknown36;         //* 1
   char         Unknown37;         //*-1
   unsigned char   Favorites;         // favorites, see definitions below
   unsigned char   CRC;
"""

def parseA(data, c):
	keyz = ['Available', 'Used', 'Skip', 'Source', 'Signal', 'Modulation', 'Locked', 'Unknown7', 
		'Tuned', 'Number', 'Unknown11', 'Unknown12', 'Preset', 'Length', 'Name', 'Frequency',
		'Unknown36', 'Unknown37', 'Favorites', 'CRC']
	
	format = "<bbbbbbbbbhblhh12sfbbBB"
	valz = struct.unpack(format, data)
	chan = OrderedDict(zip(keyz, valz))
	
	crc1 = reduce(lambda x,y: (x+y) & 0xFF, map(ord, data[:-1]))
	crc2 = ord(data[-1:])
	
	if (crc1 != crc2):
		print "CRC not matched: {0}: {1} != {2}".format(chan['Number'], crc1, crc2)
	
	if (chan['Length'] == 0):
		chan['Name'] = ''
	else:
		#chan['Name'] = chan['Name'].replace("\x00", "_").rstrip("_")
		chan['Name'] = unicode(chan['Name'].rstrip("\x00"), 'utf_16_be').encode("cp1251")
	
	c.write(";".join(map(str, chan.values())) + "\n")
	#print valz
	
def packA(valz, f):
#	l.write("In data:{0}\n".format(valz))
	
	name = list(unicode(valz[14], "cp1251").encode("utf_16_be"))
	valz[13] = 12
	valz[14] = '000000000000'
#	if (valz[13] != len(name)):
#		l.write("Text len: in {0} py {1}".format(valz[13], len(name)))
		
	freq = valz[15]
	valz[15] = '0'
	valz[19] = '0'#crc
	
	while (len(name) < 12):
		name.append('\x00')
	
	name = "".join(name)
	
	for i,x in enumerate(valz):
		valz[i] = int(x)

	valz[14] = name
	valz[15] = float(freq)
	format = "<bbbbbbbbbhblhh12sfbbBB"
	data = struct.pack(format, *valz)
#	l.write("Packed data:\n{0}\n".format(data))
	
	#Calculate CRC
	crc = reduce(lambda x,y: (x+y) & 0xFF, map(ord, list(data)))
	valz[19] = crc
#	l.write("CRC={0}\n".format(crc))
	data = struct.pack(format, *valz)
#	l.write("Final data:\n[{0}]\n".format(data))
	f.write(data)
	
#	l.write("Preset {0} - {1} bytes\n".format(valz[9], len(data)))

"""
   short         Number;            // program number (0 if entry not used)
   short         VID_PID;         // video stream PID (or -1)
   short         PCR_PID;         // program_clock_recovery PID
   unsigned short   SID;            // DVB service_identifier
   char         Unknown8;         //*0 | 1 - 0 for normal, 1 for deleted
   char         Unknown9;         //*0 | 1 - 1 for normal, 0 for deleted
   char         Source;            // signal source, see enumeration below
   char         Signal;            // signal type, see enumeration below
   char         Modulation;         // modulation, see enumeration below
   char         Unknown13;         //*0 | 1 - 0=show, 1=hide
   char         Bandwidth;         // DVB-T: 0=7MHz, 1=8MHz
   unsigned char   Type;            // DVB service_type
   char         VideoCodec;         // video codec, see enumeration below
   char         Unknown17;         //*0
   char         Unknown18;         //*1
   char         Unknown19;         //*1
   short         VideoWidth;         // video width  in pixels (or -1)
   short         VideoHeight;      // video height in pixels (or -1)
   char         Scrambled;         // scrambled service flag (0=FTA, 1=CSA)
   char         FrameRate;         // frame rate in Hertz (or -1)
   char         Unknown26;         //*0 | 1
   char         Unknown27;         //*0 | 1 - 1 for normal, 0 for deleted
   short         SymbolRate;         // symbol rate in ksymbols per second
   char         Unknown30;         //*1
   char         Locked;            //*service locked (0=open, 1=locked)
   unsigned short   ONID;            // DVB original_network_identifier
   unsigned short   NID;            // DVB network_identifier
   long         Unknown36;         //*0
   short         Provider;         // provider (ServiceProviders) (or -1)
   unsigned short   Channel;         // physical channel number
   short         LCN;            //*logical channel number (or -1)
   short         Unknown46;         //*-1
   unsigned short   TSID;            // transport_stream_identifier
   char         Unknown50[6];      //*0 0 0 0 0 0
   long         Unknown56;         //*-1
   long         Unknown60;         //*-1
   unsigned short   Name[100];         // big-endian Unicode characters
   unsigned short   Short[9];         // big-endian Unicode characters
   char         VideoFormat;      // video format, see enumeration below
   char         Unknown283;         //*0
   long         Unknown284;         //*0
   short         Unknown288;         //*0
   unsigned char   Favorites;         // favorites, see definitions below
   unsigned char   CRC;            // simple sum of the bytes above
"""

def parseD(data, c):
	keyz = ["Number", "VID_PID", "PCR_PID", "SID", "Unknown8", "Unknown9", "Source", "Signal",
		"Modulation", "Unknown13", "Bandwidth", "Type", "VideoCodec", "Unknown17", "Unknown18", 
		"Unknown19", "VideoWidth", "VideoHeight", "Scrambled", "FrameRate", "Unknown26",
		"Unknown27", "SymbolRate", "Unknown30", "Locked", "ONID", "NID", "Unknown36",
		"Provider", "Channel", "LCN", "Unknown46", "TSID", "Unknown50", "Unknown56", "Unknown60",
		"Name", "Short", "VideoFormat", "Unknown283", "Unknown284", "Unknown288", "Favorites", "CRC"]
	format = "<hhhHbbbbbbbBbbbbhhbbbbhbbHHlhHhhH6sll200s18sbblhBB"
	
	valz = struct.unpack(format, data)
	chan = OrderedDict(zip(keyz, valz))
	
	crc1 = reduce(lambda x,y: (x+y) & 0xFF, map(ord, data[:-1]))
	crc2 = ord(data[-1:])
	
	if (crc1 != crc2):
		print "CRC not matched: {0}: {1} != {2}".format(chan['Number'], crc1, crc2)
	
	#chan['Name'] = chan['Name'].replace("\x00", "_").rstrip("_")
	chan['Name'] = unicode(chan['Name'].rstrip("\x00"), 'utf_16_be').encode("cp1251")
	chan['Short'] = unicode(chan['Short'].rstrip("\x00"), 'utf_16_be').encode("cp1251")
	
	c.write(";".join(map(str, chan.values())) + "\n")
		
def packD(valz, f):
	keyz = ["Number", "VID_PID", "PCR_PID", "SID", "Unknown8", "Unknown9", "Source", "Signal",
		"Modulation", "Unknown13", "Bandwidth", "Type", "VideoCodec", "Unknown17", "Unknown18", 
		"Unknown19", "VideoWidth", "VideoHeight", "Scrambled", "FrameRate", "Unknown26",
		"Unknown27", "SymbolRate", "Unknown30", "Locked", "ONID", "NID", "Unknown36",
		"Provider", "Channel", "LCN", "Unknown46", "TSID", "Unknown50", "Unknown56", "Unknown60",
		"Name", "Short", "VideoFormat", "Unknown283", "Unknown284", "Unknown288", "Favorites", "CRC"]

	name = list(unicode(valz[36], "cp1251").encode("utf_16_be"))
	short = list(unicode(valz[37], "cp1251").encode("utf_16_be"))
	
	valz[33] = '0'
	valz[36] = '0'*200
	valz[37] = '0'*18
	valz[43] = '0'

	
	while(len(name) < 200):
		name.append("\x00")
	
	while(len(short) < 18):
		short.append("\x00")
	
	name = "".join(name)
	short = "".join(short)
		
	for i,x in enumerate(valz):
		try:
			valz[i] = int(x)
		except ValueError:
			#print i, keyz[i]
			valz[i] = x
			
	valz[33] = '\x00'*6
	valz[36] = name
	valz[37] = short
	
	format = "<hhhHbbbbbbbBbbbbhhbbbbhbbHHlhHhhH6sll200s18sbblhBB"
	data = struct.pack(format, *valz)
#	l.write("Packed data:\n{0}\n".format(data))
	
	#Calculate CRC
	crc = reduce(lambda x,y: (x+y) & 0xFF, map(ord, list(data)))
	valz[43] = crc
#	l.write("CRC={0}\n".format(crc))
	data = struct.pack(format, *valz)
#	l.write("Final data:\n[{0}]\n".format(data))
	f.write(data)
	
#	l.write("Preset {0} - {1} bytes\n".format(valz[9], len(data)))
	
def readA():
	keyz = ['Available', 'Used', 'Skip', 'Source', 'Signal', 'Modulation', 'Locked', 'Unknown7', 
		'Tuned', 'Number', 'Unknown11', 'Unknown12', 'Preset', 'Length', 'Name', 'Frequency',
		'Unknown36', 'Unknown37', 'Favorites', 'CRC']
	
	print "Unpacking map-AirA...",
	
	f = open("map-AirA", "rb")
	c = open("map-AirA.csv", "w")
	c.write(";".join(map(str, keyz))+"\n")
	
	while (True):
		data = f.read(40)
		if (len(data) != 40):
			print "done!"
			break
		parseA(data, c)
		
	f.close()
	c.close()
	
	
	print "Unpacking map-CableA...",
	f = open("map-CableA", "rb")
	c = open("map-CableA.csv", "w")
	c.write(";".join(map(str, keyz))+"\n")
	
	while (True):
		data = f.read(40)
		if (len(data) != 40):
			print "done!"
			break
		parseA(data, c)

	f.close()
	c.close()

def writeA():		
	print "Packing map-AirA...",
	f = open("map-AirA", "wb")
	c = open("map-AirA.csv", "r")
	c.readline()
	while (True):
		d = c.readline().strip()
		if (len(d) > 0):
			packA(d.split(";"), f)
		else:
			print "done!"
			break	
	
	f.close()
	c.close()
	
	print "Packing map-CableA...",

	f = open("map-CableA", "wb")
	c = open("map-CableA.csv", "r")
	c.readline()
	while (True):
		d = c.readline().strip()
		if (len(d) > 0):
			packA(d.split(";"), f)
		else:
			print "done!"
			break	
	
	f.close()
	c.close()
	
def readD():
	keyz = ["Number", "VID_PID", "PCR_PID", "SID", "Unknown8", "Unknown9", "Source", "Signal",
		"Modulation", "Unknown13", "Bandwidth", "Type", "VideoCodec", "Unknown17", "Unknown18", 
		"Unknown19", "VideoWidth", "VideoHeight", "Scrambled", "FrameRate", "Unknown26",
		"Unknown27", "SymbolRate", "Unknown30", "Locked", "ONID", "NID", "Unknown36",
		"Provider", "Channel", "LCN", "Unknown46", "TSID", "Unknown50", "Unknown56", "Unknown60",
		"Name", "Short", "VideoFormat", "Unknown283", "Unknown284", "Unknown288", "Favorites", "CRC"]
		
	print "Unpacking map-AirD...",
	f = open("map-AirD", "rb")
	c = open("map-AirD.csv", "w")
	c.write(";".join(map(str, keyz))+"\n")
	
	while (True):
		data = f.read(292)
		if (len(data) != 292):
			print "done!"
			break
		parseD(data, c)
		
	f.close()
	c.close()
	
	print "Unpacking map-CableD...",
	f = open("map-CableD", "rb")
	c = open("map-CableD.csv", "w")
	c.write(";".join(map(str, keyz))+"\n")
	
	while (True):
		data = f.read(292)
		if (len(data) != 292):
			print "done!"
			break
		parseD(data, c)

	f.close()
	c.close()

def writeD():		
	print "Packing map-AirD...",
	f = open("map-AirD", "wb")
	c = open("map-AirD.csv", "r")
	c.readline()
	while (True):
		d = c.readline().strip()
		if (len(d) > 0):
			packD(d.split(";"), f)
		else:
			print "done!"
			break	
	
	f.close()
	c.close()

	print "Packing map-CableD...",
	f = open("map-CableD", "wb")
	c = open("map-CableD.csv", "r")
	c.readline()
	while (True):
		d = c.readline().strip()
		if (len(d) > 0):
			packD(d.split(";"), f)
		else:
			print "done!"
			break	
	
	f.close()
	c.close()
	
if __name__ == "__main__":
	if (len(sys.argv) != 2) or (sys.argv[1].lower() != 'read' and sys.argv[1].lower() != 'write'):
		print "Usage: runme.py read - to decode channel list"
		print "       runme.py write - to reencode channel list"
		sys.exit(0)
		
	if (sys.argv[1].lower() == 'write'):
		writeA()
		writeD()
	else:
		readA()
		readD()