#!/usr/bin/env python
# encoding: utf-8
#
# SPDX-License-Identifier: LGPL-2.1-or-later

from __future__ import unicode_literals, absolute_import, division

try:  # Python 3
    from http.server import BaseHTTPRequestHandler, HTTPServer
except ImportError:  # Python 2
    from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

try:  # Python 3
    from socketserver import TCPServer, ThreadingMixIn
except ImportError:  # Python 2
    from SocketServer import TCPServer, ThreadingMixIn

try:  # Python 3
    from urllib.parse import unquote, quote_plus
except ImportError:  # Python 2
    from urllib import unquote, quote_plus

try:  # Python 3
  from urllib.parse import parse_qsl
except:  # Python 2
  from urlparse import parse_qsl

"""
try:  # Python 3
    from SocketServer import ThreadingTCPServer
except ImportError:  # Python 2
    from socketserver import ThreadingTCPServer
"""

import os
import re
import json
import requests
import threading
import socket
import base64
from contextlib import closing
import xbmcaddon
from .log import LOG
from .addon import profile_dir

from ttml2ssa import Ttml2SsaAddon
ttml = Ttml2SsaAddon()

session = requests.Session()
session.headers.update({'user-agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0'})
previous_token = ''

reregister_needed = False

def is_ascii(s):
  try:
    return s.isascii()
  except:
    return all(ord(c) < 128 for c in s)

def try_load_json(text):
  try:
    return json.loads(text)
  except:
    return None

mvs_o = None
def mvs():
  global mvs_o
  if not mvs_o:
    from .movistar import Movistar
    reuse_devices = xbmcaddon.Addon().getSettingBool('reuse_devices')
    mvs_o = Movistar(profile_dir, reuse_devices)
  return mvs_o


class RequestHandler(BaseHTTPRequestHandler):

    def do_GET(self):
        """Handle http get requests, used for manifest"""
        path = self.path  # Path with parameters received from request e.g. "/manifest?id=234324"
        print('HTTP GET Request received to {}'.format(path))
        try:
        #if True:
            if 'manifest' in path:
              pos = path.find('=')
              url = path[pos+1:]
              LOG('url: {}'.format(url))
              response = session.get(url, allow_redirects=True)
              LOG('headers: {}'.format(response.headers))
              baseurl = os.path.dirname(response.url)
              LOG('baseurl: {}'.format(baseurl))
              content = response.content.decode('utf-8')
              pos = content.find('<Period id')
              if pos > -1:
                content = content[:pos] + '<BaseURL>' + baseurl + '/</BaseURL>' + content[pos:]
              content = content.replace('lang="qaa"', 'lang="eng"')
              if not xbmcaddon.Addon().getSettingBool('use_ttml2ssa'):
                LOG(self.headers.get('Host'))
                my_address = 'http://' + self.headers.get('Host')
                LOG('my_address: {}'.format(my_address))
                content = content.replace('mimeType="application/ttml+xml"', 'mimeType="text/vtt"')
                content = re.sub(r'<BaseURL>(.*?)\.ttml<\/BaseURL>', r'<BaseURL>{}/?subtitle={}/\1.ttml</BaseURL>'.format(my_address, baseurl), content)
              #LOG('content: {}'.format(content))
              manifest_data = content
              self.send_response(200)
              #self.send_header('Content-type', 'application/xml')
              self.send_header('Content-type', 'text/plain')
              self.end_headers()
              self.wfile.write(manifest_data.encode('utf-8'))
            elif 'subtitle' in path:
              pos = path.find('=')
              url = path[pos+1:]
              LOG('subtitle url: {}'.format(url))
              response = session.get(url, allow_redirects=True)
              content = response.content
              ttml.parse_ttml_from_string(content)
              sub_data = ttml.generate_vtt()
              self.send_response(200)
              self.send_header('Content-type', 'text/plain')
              self.end_headers()
              self.wfile.write(sub_data.encode('utf-8'))
            elif 'fragment' in path:
              pos = path.find('=')
              url = path[pos+1:]
              LOG('url: {}'.format(url))
              self.send_response(301)
              self.send_header('Location', url)
              self.end_headers()
            else:
              self.send_response(404)
              self.end_headers()
        except Exception:
            self.send_response(500)
            self.end_headers()

    def do_POST(self):
        """Handle http post requests, used for license"""
        path = self.path  # Path with parameters received from request e.g. "/license?id=234324"
        print('HTTP POST Request received to {}'.format(path))
        if '/license' not in path:
            self.send_response(404)
            self.end_headers()
            return
        try:
        #if True:
            pos = path.find('?')
            path = path[pos+1:]
            params = dict(parse_qsl(path))
            LOG('params: {}'.format(params))

            length = int(self.headers.get('content-length', 0))
            isa_data = self.rfile.read(length)
            LOG('isa_data length: {}'.format(length))
            LOG('isa_data: {}'.format(base64.b64encode(isa_data)))

            token = params['token']
            LOG('token: {}'.format(token))

            global previous_token, reregister_needed
            while True:
              LOG('reregister_needed: {}'.format(reregister_needed))
              if reregister_needed and xbmcaddon.Addon().getSettingBool('reregister'):
                mvs().unregister_device()
                mvs().register_device()

              if previous_token == token and params['stype'] == 'vod':
                d = mvs().open_session(params['session_request'], params['session_token'])
                LOG('open_session: d: {}'.format(d))
                if 'resultData' in d and 'cToken' in d['resultData']:
                  token = d['resultData']['cToken']
                  LOG('new token: {}'.format(token))
              previous_token = token

              headers = {
              'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:88.0) Gecko/20100101 Firefox/88.0',
              'Accept': '*/*',
              'Accept-Language': 'es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3',
              'Referer': 'https://ver.movistarplus.es/',
              'nv-authorizations': quote_plus(token),
              'Origin': 'https://ver.movistarplus.es',
              }
              LOG('headers: {}'.format(headers))

              url = 'https://wv-ottlic-f3.imagenio.telefonica.net/TFAESP/wvls/contentlicenseservice/v1/licenses'
              response = session.post(url, data=isa_data, headers=headers)
              license_data = response.content
              LOG('license response length: {}'.format(len(license_data)))
              if is_ascii(license_data):
                LOG('license response: {}'.format(license_data))
                d = try_load_json(license_data)
                if d and 'errorCode' in d:
                  from .gui import show_notification
                  show_notification('Error {}: {}'.format(d['errorCode'], d['message']))
                  if d['errorCode'] == 4027:
                    if not reregister_needed and xbmcaddon.Addon().getSettingBool('reregister'):
                      reregister_needed = True
                    else:
                      break
              else:
                LOG('license response: {}'.format(base64.b64encode(license_data)))
                break

            self.send_response(response.status_code)
            self.end_headers()
            self.wfile.write(license_data)
        except Exception:
            self.send_response(500)
            self.end_headers()


HOST = '127.0.0.1'
PORT = 57011

class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    daemon_threads = True

class Proxy(object):
    started = False

    def check_port(self, port=0, default=False):
      try:
        with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
          s.bind((HOST, port))
          s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
          return s.getsockname()[1]
      except:
        return default

    def start(self):
        if self.started:
            return

        port = self.check_port(PORT)
        if not port:
          port = self.check_port(0)
        LOG('port: {}'.format(port))

        self._server = ThreadedHTTPServer((HOST, port), RequestHandler)
        self._server.allow_reuse_address = True
        self._httpd_thread = threading.Thread(target=self._server.serve_forever)
        self._httpd_thread.start()
        self.proxy_address = 'http://{}:{}'.format(HOST, port)
        self.started = True
        LOG("Proxy Started: {}:{}".format(HOST, port))

    def stop(self):
        if not self.started:
            return

        self._server.shutdown()
        self._server.server_close()
        self._server.socket.close()
        self._httpd_thread.join()
        self.started = False
        LOG("Proxy: Stopped")