import json
import logging
import random
import re
import ssl
from urllib.parse import urlparse

from streamlink.plugin import Plugin
from streamlink.plugin.api import useragents
from streamlink.stream import HLSStream
from streamlink.utils import parse_json
from websocket import create_connection

API_CC = "https://api.crazycash.tv/token"
API_ABLY = "https://solarcomms-rest.ably.io/keys/{0}/requestToken"
CHAT_URL = "wss://solarcomms-realtime.ably.io/?access_token={0}&format=json&echo=false&heartbeats=true&v=1.2&lib=js-web-1.2.4"
_url_user_re = re.compile(r"https?://(\w+\.)?crazycash\.tv/(?P<user_id>\d+)")
_url_stream_re = re.compile(r"https?://(\w+\.)?crazycash\.tv/view-stream/(?P<stream_id>\d+)")

log = logging.getLogger(__name__)


class Crazycash(Plugin):
    _msg_serial = 0
    _stream_id = None
    _user_id = None

    @classmethod
    def can_handle_url(cls, url):
        return _url_stream_re.match(url) or _url_user_re.match(url)

    def _send_msg(self, ws, m):
        self._msg_serial += 1
        m["msgSerial"] = self._msg_serial
        log.debug(">> {0}".format(m))
        ws.send(json.dumps(m))

    def _make_req(self, client_id):
        rid = '%x' % random.getrandbits(33)
        req = {
            "action": 15,
            "channel": "streams:" + client_id
        }
        if self._stream_id:
            req.update({
                "messages": [{
                    "name": "get_stream", "encoding": "json",
                    "data": '{{"id":"{0}","req_id":"{1}"}}'.format(self._stream_id, rid)
                }]
            })
        else:
            req.update({
                "messages": [{
                    "name": "get_streams", "encoding": "json",
                    "data": '{{"country":"Worldwide","req_id":"{0}"}}'.format(rid)
                }]
            })
        return req

    def _get_stream_info(self):
        stream_match = _url_stream_re.match(self.url)
        user_match = _url_user_re.match(self.url)
        headers = {"User-Agent": useragents.CHROME}
        token_data = self.session.http.get(API_CC, headers=headers).json()
        ably_token = self.session.http.post(API_ABLY.format(token_data.get("keyName")), headers=headers,
                                            json=token_data).json()
        log.debug("proxies={0}".format(self.session.http.proxies))
        prx = self.session.http.proxies.get("https", "") or self.session.http.proxies.get("http", "")
        pu = urlparse(prx)
        proxy_auth = (pu.username, pu.password)
        ws_url = CHAT_URL.format(ably_token.get("token"))
        log.debug("ws_url: {0}".format(ws_url))
        cid = token_data.get("clientId")
        join_req = {"action": 10, "channel": "streams:" + cid}
        if stream_match:
            self._stream_id = stream_match.group("stream_id")
        else:
            self._user_id = user_match.group("user_id")
        ws = create_connection(ws_url, http_proxy_host=pu.hostname, http_proxy_port=pu.port,
                               http_proxy_auth=proxy_auth, sslopt={"cert_reqs": ssl.CERT_NONE})
        try:
            while True:
                r_msg = ws.recv()
                if not r_msg:
                    break
                log.debug(r_msg)
                res = parse_json(r_msg)
                action = res.get("action")
                if action == 4:
                    self._send_msg(ws, join_req)
                elif action == 11:
                    self._send_msg(ws, self._make_req(cid))
                elif action == 15:
                    raw_str = res.get("messages")[0].get("data")
                    data = json.loads(raw_str).get('data')
                    if data and data.get("streams"):
                        for room in data.get("streams"):
                            if str(room.get("user_id")) == self._user_id:
                                self._stream_id = room.get("id")
                                self._send_msg(ws, self._make_req(cid))
                                break
                        else:
                            break
                    elif data.get('code') == 404:
                        break
                    elif data.get("stream_id"):
                        return data
        except Exception as e:
            log.debug(e)
        finally:
            ws.close()
        return {}

    def _get_streams(self):
        si = self._get_stream_info()
        log.debug("_get_stream_info(): {0!r}".format(si))
        if si:
            log.info("Stream info: nickname: {nickname} | live: {live} | private: {private}".format(**si))
            srv = random.choice(si.get("edge_nodes"))
            playlist = "https://{0}.crazycash.tv:20443/instream_abr/{1}/playlist.m3u8".format(srv, si.get("stream_id"))
            return HLSStream.parse_variant_playlist(self.session, playlist)
        else:
            log.info("This stream is no longer online")


__plugin__ = Crazycash