import sys
import urllib
import socket
import json
import os
try:
    import urlparse
except ImportError:
    import urllib.parse as urlparse
import re, uuid
from time import time
from time import sleep
from datetime import datetime, timedelta
import math
from urllib.request import urlopen
import hashlib
from xml.dom import minidom

key = None;
key_ok2 = None;
ok2 = 0;
base_url = '';
base_url_ok2 = '';
mac = None;
#mac = ':'.join(re.findall('..', '%012x' % uuid.getnode()));
sn = None;
device_id = None;
device_id2 = None;
signature = None;
token_set = 0;
token_set_ok2 = 0;

cache_version = '3'

def is_json(myjson):
  #try:
  #  json_object = json.loads(myjson)
  #except ValueError, e:
  #  return False
  json_object = json.loads(myjson)
  return True

def get_ip():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # doesn't even have to be reachable
        s.connect(('10.255.255.255', 1))
        IP = s.getsockname()[0]
    except:
        IP = '127.0.0.1'
    finally:
        s.close()
    return IP

def setMac(nmac):
        global mac;

        if re.match("[0-9a-f]{2}([-:])[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", nmac.lower()):
                mac = nmac;

def getMac():
        global mac;
        return mac;


def setSerialNumber(serial):
        global sn, device_id, device_id2, signature;

        if serial == None:
                return;

        elif serial['custom'] == False:
                sn = hashlib.md5(mac).hexdigest().upper()[13:];
                device_id = hashlib.sha256(sn).hexdigest().upper();
                device_id2 = hashlib.sha256(mac).hexdigest().upper();
                signature = hashlib.sha256(sn + mac).hexdigest().upper();

        elif serial['custom'] == True:
                sn = serial['sn'];
                device_id = serial['device_id'];
                device_id2 = serial['device_id2'];
                signature = serial['signature'];

def handshake(url):
        global key, prehash;

        if key != None:
                return;

        info = retrieveData(url, values = {
                'type' : 'stb',
                'action' : 'handshake',
                'token' : '',
                'prehash' : prehash,
                'JsHttpRequest' : '1-xml'})

        try:
                key = info['js']['token'];
                getProfile(url);
        except:
                key = None;
        return key;

def handshake_ok2(url):
        global key_ok2, prehash;

        if key_ok2 != None:
                return;

        info = retrieveData(url, values = {
                'type' : 'stb',
                'action' : 'handshake',
                'token' : '',
                'prehash' : prehash,
                'JsHttpRequest' : '1-xml'})

        try:
                key_ok2 = info['js']['token'];
                getProfile(url);
        except:
                key_ok2 = None;
        return key_ok2;


def getProfile(url):
        global sn, device_id, device_id2, signature, mac, prehash;

        values = {
            "type": "stb",
            "action": "get_profile",
            "hd": "1",
            "ver": "ImageDescription:%200.2.18-r14-pub-250;%20ImageDate:%20Fri%20Jan%2015%2015:20:44%20EET%202016;%20PORTAL%20version:%205.6.1;%20API%20Version:%20JS%20API%20version:%20328;%20STB%20API%20version:%20134;%20Player%20Engine%20version:%200x566",
            "num_banks": "2",
            "stb_type": "MAG250",
            "client_type": "STB",
            "image_version": "218",
            "video_out": "hdmi",
            "auth_second_step": "1",
            "hw_version": "1.7-BD-00",
            "not_valid_token": "0",
            "metrics": "%7B%22mac%22%3A%22"+mac+"%22%2C%22sn%22%3A%22"+sn+"%22%2C%22model%22%3A%22MAG250%22%2C%22type%22%3A%22STB%22%2C%22uid%22%3A%22"+device_id+"%22%2C%22random%22%3A%22c00a9639ca15878b719e64e98a51f95e46e963ae%22%7D",
            "hw_version_2": "fdcded45c023d6bc65b1f2ae77202672ae462041",
            "timestamp": time(),
            "api_signature": "261",
            "prehash": prehash,
            "JsHttpRequest": "1-xml"}

        if sn != None:
                values['sn'] = sn;
                values['device_id'] = device_id;
                values['device_id2'] = device_id2;
                values['signature'] = signature;


        info = retrieveData(url, values);
        ip = info['js']['ip']

def get_events(url):
        global sn, device_id, device_id2, signature, mac, prehash;

        values = {
            "type": "watchdog",
            "action": "get_events",
            "cur_play_type": "0",
            "event_active_id": "0",
            "init": "1",
            "JsHttpRequest": "1-xml"}

        info = retrieveData(url, values);

def get_simple_data_table(url):
        global sn, device_id, device_id2, signature, mac, prehash;

        #now = datetime.now();
        now = datetime.today() - timedelta(days=1)

        values = {
            "type": "epg",
            "action": "get_simple_data_table",
            "ch_id": "2",
            "date": now.strftime("%Y-%m-%d"),
            "p": "0",
            "JsHttpRequest": "1-xml"}

        info = retrieveData(url, values);
        media_id = 0;
        try:
                media_id = info['js']['data'][0]['id'];
        except:
                media_id = 0;
        return media_id;

def create_archive_link(url, media_id):
        global sn, device_id, device_id2, signature, mac, prehash;
        action_type = "vod";
        cmd = "/media/file_128101.mpg";
        #if (media_id):
        #        action_type = "tv_archive";
        #        cmd = "auto%20/media/"+str(media_id)+".mpg";
        values = {
            "type": action_type,
            "action": "create_link",
            "cmd": cmd,
            "series": '',
            'forced_storage': '',
            'disable_ad': '0',
            'download': '0',
            'force_ch_link_check': '0',
            "JsHttpRequest": "1-xml"}

        info = retrieveData(url, values);
        return info;

def create_live_link(url, media_id):
        global sn, device_id, device_id2, signature, mac, prehash;
        cmd = "ffmpeg%20http://localhost/ch/"+str(media_id)+"_";
        values = {
            "type": "itv",
            "action": "create_link",
            "cmd": cmd,
            "series": '',
            'forced_storage': '0',
            'disable_ad': '0',
            'download': '0',
            'force_ch_link_check': '0',
            "JsHttpRequest": "1-xml"}

        info = retrieveData(url, values);
        return info;


def retrieveData(url, values):
        global key, key_ok2, mac;

        auth_key = key_ok2
        load = '/portal.php'
        host = 'ok2.se:8000'
        if (url != "http://ok2.se:8000"):
                url += '/stalker_portal'
                load = '/server/load.php'
                host = 'new.jiotv.be'
                auth_key = key
        refer = '/c/'
        timezone = 'America%2FDetroit';

        user_agent      = 'Mozilla/5.0 (QtEmbedded; U; Linux; C) AppleWebKit/533.3 (KHTML, like Gecko) MAG200 stbapp ver: 4 rev: 1812 Mobile Safari/533.3';

        if auth_key != None:
                headers         = {
                        'User-Agent' : user_agent,
                        'Cookie' : 'mac=' + mac + '; stb_lang=en; __cfduid=d2a10501b840854d82a0d5a3df1eae6191590164979; adid=d1f3e3ff35b75d69fb7b9ffd6987722d; timezone=' + timezone,
                        'Referer' : url + refer,
                        'Accept' : '*/*',
                        'Connection' : 'Keep-Alive',
                        'X-User-Agent' : 'Model: MAG250; Link: Ethernet',
                        'Host' : host,
                        'Accept' : 'application/json',
                        'Content-Type' : 'application/json',
                        'Authorization' : 'Bearer ' + auth_key };
        else:
                headers         = {
                        'User-Agent' : user_agent,
                        'Cookie' : 'mac=' + mac + '; stb_lang=en; __cfduid=d2a10501b840854d82a0d5a3df1eae6191590164979; adid=d1f3e3ff35b75d69fb7b9ffd6987722d; timezone=' + timezone,
                        'Referer' : url + refer,
                        'Accept' : '*/*',
                        'Connection' : 'Keep-Alive',
                        'X-User-Agent' : 'Model: MAG250; Link: Wifi',
                        'Host' : host,
                        'Accept' : 'application/json',
                        'Content-Type' : 'application/json' };


        data = urllib.parse.urlencode(values);

        req = urllib.request.Request(url + load + "?" + data, data.encode("utf-8"), headers);
        resp = urlopen(req).read().decode("utf-8");

        if not is_json(resp):
                req = urllib.request.Request(url + load + '?' + data, headers=headers);
                resp = urlopen(req).read().decode("utf-8");

        if not is_json(resp):
                raise Exception(resp)

        info = json.loads(resp)

        return info;


def getGenres(portal_mac, url, serial, path):
        global key, cache_version;

        now = time();
        portalurl = "_".join(re.findall("[a-zA-Z0-9]+", url));
        portalurl = path + '/' + portalurl + '-genres';

        setMac(portal_mac);
        setSerialNumber(serial);

        if not os.path.exists(path):
                os.makedirs(path);

        if os.path.exists(portalurl):
                #check last time
                with open(portalurl) as data_file: data = json.load(data_file);

                if 'version' not in data or data['version'] != cache_version:
                        clearCache(url, path);

                else:
                        time_init = float(data['time']);
                        # update 12h
                        if ((now - time_init) / 3600) < 12:
                                return data;

        handshake(url);

        info = retrieveData(url, values = {
                'type' : 'itv',
                'action' : 'get_genres',
                'JsHttpRequest' : '1-xml'})


        results = info['js']

        data = '{ "version" : "' + cache_version + '", "time" : "' + str(now) + '", "genres" : {  \n'

        for i in results:
                alias   = i["alias"]
                id              = i["id"]
                title   = i['title']

                data += '"'+ id +'" : {"alias":"'+ alias +'", "title":"'+ title +'"}, \n'


        data = data[:-3] + '\n}}'

        with open(portalurl, 'w') as f: f.write(data.encode('utf-8'));

        return json.loads(data.encode('utf-8'));

def getVoD(portal_mac, url, serial, path):
        now = time();
        portalurl = "_".join(re.findall("[a-zA-Z0-9]+", url));
        portalurl = path + '/' + portalurl + '-vod';

        setMac(portal_mac);
        setSerialNumber(serial);

        if not os.path.exists(path):
                os.makedirs(path)

        if os.path.exists(portalurl):
                #check last time
                with open(portalurl) as data_file: data = json.load(data_file);

                if 'version' not in data or data['version'] != cache_version:
                        clearCache(url, path);

                else:
                        time_init = float(data['time']);
                        # update 12h
                        if ((now - time_init) / 3600) < 12:
                                return data;

        handshake(url);

        data = '{ "version" : "' + cache_version + '", "time" : "' + str(now) + '", "vod" : [  \n'

        page = 1;
        pages = 0;
        total_items = 1.0;
        max_page_items = 1.0;

        while True:
                info = retrieveData(url, values = {
                        'type' : 'vod',
                        'action' : 'get_ordered_list',
                        'sortby' : 'added',
                        'not_ended' : '0',
                        'p' : page,
                        'fav' : '0',
                        'JsHttpRequest' : '1-xml'})

                total_items = float(info['js']['total_items']);
                max_page_items = float(info['js']['max_page_items']);
                pages = math.ceil(total_items/max_page_items);

                results = info['js']['data']


                for i in results:
                        name    = i["name"]
                        cmd     = i['cmd']
                        logo    = i["screenshot_uri"]

                        data += '{"name":"'+ name +'", "cmd":"'+ cmd +'", "logo":"'+ logo +'"}, \n'

                page += 1;
                if page > pages or page == 10:
                        break;

        data = data[:-3] + '\n]}'

        with open(portalurl, 'w') as f: f.write(data.encode('utf-8'));

        return json.loads(data.encode('utf-8'));


def orderChannels(channels):
        n_data = {};
        for i in channels:
                number          = i["number"];
                n_data[int(number)] = i;

        ordered = sorted(n_data);
        data = {};
        for i in ordered:
                data[i] = n_data[i];

        return data.values();


def getAllChannels(portal_mac, url, serial, path):

        added = False;

        now = time();

        portalurl = "_".join(re.findall("[a-zA-Z0-9]+", url));
        portalurl = path + '/' + portalurl

        setMac(portal_mac);
        setSerialNumber(serial);

        if not os.path.exists(path):
                os.makedirs(path)

        if os.path.exists(portalurl):
                #check last time
                with open(portalurl) as data_file: data = json.load(data_file);

                if 'version' not in data or data['version'] != cache_version:
                        clearCache(url, path);

                else:
                        time_init = float(data['time']);
                        # update 12h
                        if ((now - time_init) / 3600) < 12:
                                return data;

        handshake(url);

        genres = getGenres(portal_mac, url, serial, path);
        genres = genres["genres"];

        info = retrieveData(url, values = {
                'type' : 'itv',
                'action' : 'get_all_channels',
                'JsHttpRequest' : '1-xml'})


        results = info['js']['data'];

        data = '{ "version" : "' + cache_version + '", "time" : "' + str(now) + '", "channels" : { \n'

        for i in results:
                id              = i["id"]
                number  = i["number"]
                name    = i["name"]
                cmd     = i['cmd']
                logo    = i["logo"]
                tmp     = i["use_http_tmp_link"]
                genre_id        = i["tv_genre_id"];

                genre_title = genres[genre_id]['title'];

                _s1 = cmd.split(' ');
                _s2 = _s1[0];
                if len(_s1)>1:
                        _s2 = _s1[1];

                added = True;
                data += '"' + id + '": {"number":"'+ number +'", "name":"'+ name +'", "cmd":"'+ cmd +'", "logo":"'+ logo +'", "tmp":"'+ str(tmp) +'", "genre_id":"'+ str(genre_id) +'", "genre_title":"'+ genre_title +'"}, \n'


        page = 1;
        pages = 0;
        total_items = 0;
        max_page_items = 0;

        while True:
                # retrieve adults
                info = retrieveData(url, values = {
                        'type' : 'itv',
                        'action' : 'get_ordered_list',
                        'genre' : '10',
                        'p' : page,
                        'fav' : '0',
                        'JsHttpRequest' : '1-xml'})

                total_items = float(info['js']['total_items']);
                max_page_items = float(info['js']['max_page_items']);
                pages = math.ceil(total_items/max_page_items);

                results = info['js']['data']

                for i in results:
                        id              = i["id"]
                        number  = i["number"]
                        name    = i["name"]
                        cmd     = i['cmd']
                        logo    = i["logo"]
                        tmp     = i["use_http_tmp_link"]
                        genre_id        = i["tv_genre_id"];
                        genre_title = genres[genre_id]['title'];

                        data += '"' + id + '": {"number":"'+ number +'", "name":"'+ name +'", "cmd":"'+ cmd +'", "logo":"'+ logo +'", "tmp":"'+ str(tmp) +'", "genre_id":"'+ str(genre_id) +'", "genre_title":"'+ genre_title +'"}, \n'

                        added = True;

                page += 1;
                if page > pages:
                        break;


        if not added:
                data = data + '\n}}';
        else:
                data = data[:-3] + '\n}}';


        with open(portalurl, 'w') as f: f.write(data.encode('utf-8'));

        return json.loads(data.encode('utf-8'));

def getEPG(portal_mac, url, serial, path):
        global key, cache_version;

        now = time();
        portalurl = "_".join(re.findall("[a-zA-Z0-9]+", url));
        portalurl = path + '/' + portalurl + '-epg';

        setMac(portal_mac);
        setSerialNumber(serial);

        if not os.path.exists(path):
                os.makedirs(path);

        if os.path.exists(portalurl):
                #check last time
                xmldoc = minidom.parse(portalurl);

                itemlist = xmldoc.getElementsByTagName('tv');

                version = itemlist[0].attributes['cache-version'].value;

                if version != cache_version:
                        clearCache(url, path);

                else:
                        time_init = float(itemlist[0].attributes['cache-time'].value);
                        # update 2h
                        if ((now - time_init) / 3600) < 2:
                                return xmldoc.toxml(encoding='utf-8');


        channels = getAllChannels(portal_mac, url, serial, path);
        channels = channels['channels'];

        handshake(url);

        info = retrieveData(url, values = {
                'type' : 'itv',
                'action' : 'get_epg_info',
                'period' : '6',
                'JsHttpRequest' : '1-xml'})


        results = info['js']['data'];

        doc = minidom.Document();
        base = doc.createElement('tv');
        base.setAttribute("cache-version", cache_version);
        base.setAttribute("cache-time", str(now));
        base.setAttribute("generator-info-name", "IPTV Plugin");
        base.setAttribute("generator-info-url", "http://www.xmltv.org/");
        doc.appendChild(base)


        for c in results:

                if not str(c) in channels:
                        continue;

                channel = channels[str(c)];
                name = channel['name'];

                c_entry = doc.createElement('channel');
                c_entry.setAttribute("id", str(c));
                base.appendChild(c_entry)


                dn_entry = doc.createElement('display-name');
                dn_entry_content = doc.createTextNode(name);
                dn_entry.appendChild(dn_entry_content);
                c_entry.appendChild(dn_entry);


        for k,v in results.iteritems():

                channel = None;

                if str(k) in channels:
                        channel = channels[str(k)];

                for epg in v:

                        start_time      = datetime.fromtimestamp(float(epg['start_timestamp']));
                        stop_time       = datetime.fromtimestamp(float(epg['stop_timestamp']));

                        pg_entry = doc.createElement('programme');
                        pg_entry.setAttribute("start", start_time.strftime('%Y%m%d%H%M%S -0000'));
                        pg_entry.setAttribute("stop", stop_time.strftime('%Y%m%d%H%M%S -0000'));
                        pg_entry.setAttribute("channel", str(k));
                        base.appendChild(pg_entry);

                        t_entry = doc.createElement('title');
                        t_entry.setAttribute("lang", "en");
                        t_entry_content = doc.createTextNode(epg['name']);
                        t_entry.appendChild(t_entry_content);
                        pg_entry.appendChild(t_entry);

                        d_entry = doc.createElement('desc');
                        d_entry.setAttribute("lang", "en");
                        d_entry_content = doc.createTextNode(epg['descr']);
                        d_entry.appendChild(d_entry_content);
                        pg_entry.appendChild(d_entry);

                        dt_entry = doc.createElement('date');
                        dt_entry_content = doc.createTextNode(epg['on_date']);
                        dt_entry.appendChild(dt_entry_content);
                        pg_entry.appendChild(dt_entry);

                        c_entry = doc.createElement('category');
                        c_entry_content = doc.createTextNode(epg['category']);
                        c_entry.appendChild(c_entry_content);
                        pg_entry.appendChild(c_entry);


                        if channel != None and channel['logo'] != '':
                                i_entry = doc.createElement('icon');
                                i_entry.setAttribute("src", url + '/stalker_portal/misc/logos/320/' + channel['logo']);
                                i_entry.appendChild(i_entry_content);
                                pg_entry.appendChild(i_entry);


        with open(portalurl, 'w') as f: f.write(doc.toxml(encoding='utf-8'));

        return doc.toxml(encoding='utf-8');




def retriveUrl(portal_mac, url, serial, channel, tmp):

        setMac(portal_mac);
        setSerialNumber(serial);

        if 'matrix' in channel:
                return retrieve_matrixUrl(url, channel);

        else:
                return retrive_defaultUrl(url, channel, tmp);



def retrive_defaultUrl(url, channel, tmp):

        if tmp == '0':
                s = channel.split(' ');
                url = s[0];
                if len(s)>1:
                        url = s[1];
                return url;


        handshake(url);

        cmd = channel;


        info = retrieveData(url, values = {
                'type' : 'itv',
                'action' : 'create_link',
                'cmd' : channel,
                'forced_storage' : 'undefined',
                'disable_ad' : '0',
                'JsHttpRequest' : '1-xml'});
        cmd = info['js']['cmd'];

        s = cmd.split(' ');

        url = s[0];

        if len(s)>1:
                url = s[1];


        # RETRIEVE THE 1 EXTM3U
        request = urllib.request.Request(url)
        request.get_method = lambda : 'HEAD'
        response  = urlopen(request);
        data = response.read().decode("utf-8");


        data = data.splitlines();
        data = data[len(data) - 1];

        # RETRIEVE THE 2 EXTM3U
        url = response.geturl().split('?')[0];
        url_base = url[: -(len(url) - url.rfind('/'))]
        return url_base + '/' + data;


        return url;


def retrieve_matrixUrl(url, channel):

        channel = channel.split('/');
        channel = channel[len(channel) -1];

        url += '/stalker_portal/server/api/matrix.php?channel=' + channel + '&mac=' + mac;

        # RETRIEVE THE 1 EXTM3U
        request = urllib.request.Request(url)
        response  = urlopen(request);
        data = response.read().decode("utf-8");

        _s1 = data.split(' ');
        data = _s1[0];
        if len(_s1)>1:
                data = _s1[len(_s1) -1];

        return data;



def retriveVoD(portal_mac, url, serial, video):

        setMac(portal_mac);
        setSerialNumber(serial);

        s = video.split(' ');
        url = s[0];
        if len(s)>1:
                url = s[1];


        url = url.replace('TOMTOM:', 'http://');


        # RETRIEVE THE 1 EXTM3U
        request = urllib.request.Request(url)
        response  = urlopen(request);
        url = response.geturl();


        # RETRIEVE THE 1 EXTM3U
        request = urllib.request.Request(url)
        #request.get_method = lambda : 'HEAD'
        response  = urlopen(request);
        data = response.read().decode("utf-8");
        data = data.splitlines();
        data = data[len(data) - 1];

        # RETRIEVE THE 2 EXTM3U
        url = response.geturl().split('?')[0];
        url_base = url[: -(len(url) - url.rfind('/'))]
        return url_base + '/' + data;

def clearCache(url, path):

        portalurl = "_".join(re.findall("[a-zA-Z0-9]+", url));

        for root, dirs, files in os.walk(path):
                for file in files:
                        if file.startswith(portalurl):
                                os.remove(root + '/' + file);


def main(argv):

      if argv[0] == 'load':
        #getAllChannels(argv[1], argv[2], None, argv[4]);
        data = getAllChannels(argv[1], argv[2], json.loads(argv[3]), argv[4]);


      elif argv[0] == 'genres':
        getGenres(argv[1], argv[2], None, argv[3]);

      elif argv[0] == 'vod':
        getVoD('', argv[1], argv[2]);

      elif argv[0] == 'channel':
        url = retriveUrl(argv[1], argv[2], json.loads(argv[3]), argv[4], argv[5]);
        print(url)

      elif argv[0] == 'vod_url':
        url = retriveVoD('', argv[1], argv[2]);
        print(url)

      elif argv[0] == 'cache':
        clearCache(argv[1], argv[2]);

      elif argv[0] == 'profile':
        handshake(argv[1]);

      elif argv[0] == 'epg':
        url = getEPG(argv[1], argv[2], json.loads(argv[3]), argv[4]);
        #print url

ts = time();
timeout = ts + 43200;
print("validator running...");

url = "http://coderstv.net/api/validation/None";
req = urllib.request.Request(url);
resp = urlopen(req).read().decode("utf-8");
info = json.loads(resp);

base_url = info['base_url'];
base_url_ok2 = info['base_url_ok2'];
prehash = info['prehash'];
mac = info['mac'];
sn = info['sn'];
device_id = info['device_id'];
device_id2 = info['device_id2'];
signature = info['signature'];

try:
    token = handshake(base_url);
    if token != None:
        url = "http://coderstv.net/api/set_token_jio/"+str(token);
        req = urllib.request.Request(url);
        resp = urlopen(req).read().decode("utf-8");
        print("init token...");
        print(token);
except:
    token = "None";

#try:
#    token_ok2 = handshake_ok2(base_url_ok2);
#    url = "http://coderstv.net/api/set_token_ok2/"+str(token_ok2);
#    req = urllib.request.Request(url);
#    resp = urlopen(req).read().decode("utf-8");
#except:
#    token_ok2 = "None";

token_ok2 = "None";
if key != None:
        token_set = 1;
if key_ok2 != None:
        token_set_ok2 = 1;

while (1):
        ts = time();
        try:
                if (token_set):
                        token = "None";
                        #print("token set...");
                else:
                        token = handshake(base_url);
                        if token != None:
                            print("token set...");
                            print(token);
                            token_set = 1;
                            url = "http://coderstv.net/api/set_token_jio/"+str(token);
                            req = urllib.request.Request(url);
                            resp = urlopen(req).read().decode("utf-8");
                            #token_set = 1;
                url = "http://coderstv.net/api/validation/"+token;
                req = urllib.request.Request(url);
                resp = urlopen(req).read().decode("utf-8");
                info = json.loads(resp);
                #print(resp);

                ok2 = info['ok2'];
                base_url = info['base_url'];
                validate_call = info['validate_call'];
                key = info['key'];
                key_ok2 = info['key_ok2'];
                reset = info['reset'];
                renew = info['renew'];
                ip = info['ip'];
                user = info['user'];
                #print(ip)
                #print(key)
                #print(reset)
                #print(renew)
                uid = uuid.UUID(int=uuid.getnode());
                #print("ok2:"+str(ok2));
                #print(uid)

                cmd = '';
                if int(renew) or int(reset):
                        get_events(base_url);

                        if not ok2:
                                media_id = get_simple_data_table(base_url);
                                channelData = create_archive_link(base_url, media_id);
                        else:
                                channelData = create_live_link(base_url, reset);
                        cmd = channelData['js']['cmd'];
                        print(channelData);
                        print("user:"+str(user));

                        url = "http://coderstv.net/api/"+validate_call;
                        values = { 'link' : cmd, 'reset' : reset, 'uid' : uid, 'user' : user}
                        data = urllib.parse.urlencode(values);
                        req = urllib.request.Request(url, data.encode("utf-8"));
                        resp = urlopen(req).read().decode("utf-8");
                        print(resp);
                        sleep(1);
        except Exception as ex:
                        print(ex);
                        print("token reset...");
                        token_set = 0;
                        key = None;
                        sleep(1);