[System.Reflection.Assembly]::LoadFrom("WebDriver.dll")

$save_directory = "b:\AAF\ppp\JenySmith.net\crazycash\"
$start_waiting_time = 20 #seconds
$max_waiting_time = 60 * 10 #seconds
$waiting_time = $max_waiting_time
$nickname = Read-Host "nickname"

$ChromeOptions = New-Object OpenQA.Selenium.Chrome.ChromeOptions
$ChromeOptions.AddArgument('headless')

while($true) {
  Clear-Host
  $waiting_time = $waiting_time * 1.1
  if ($waiting_time -gt $max_waiting_time) {
    $waiting_time = $max_waiting_time
  }
  $ChromeDriver = New-Object OpenQA.Selenium.Chrome.ChromeDriver($ChromeOptions)
  $Host.UI.RawUI.WindowTitle = "$nickname" + " - connection..."
  $ChromeDriver.Url = 'https://crazycash.tv/'
  Start-Sleep -seconds 5
  $items = $ChromeDriver.FindElementsByClassName('streams__item')
  foreach ($item in $items) {
    try {
      $name =  $item.FindElementByClassName('stream-preview__nickname').GetAttribute('textContent')
      if ($name -eq $nickname) {
        $waiting_time = $start_waiting_time
        $thumb = $item.FindElementByClassName('stream-preview__preview-image').GetCssValue('background-image')
        $id = $thumb | Select-String -Pattern 'stream\/(.*)\/thumbnail' | %{ $_.Matches.Groups[1].Value }
        $stream_url = 'https://darcie.crazycash.tv:20443/instream_abr/' + $id + '/playlist.m3u8'
        $ChromeDriver.Quit()
        Clear-Host
        $date_time = get-date -format yyyy-MM-dd_HH-mm-ss
        $output_file = $save_directory + "CrazyCash-" + $nickname + "-" + $date_time + ".ts"
        $Host.UI.RawUI.WindowTitle = "$nickname" + " - recording"
        & streamlink.exe --http-no-ssl-verify --hls-timeout 20 --default-stream best --url $stream_url --output $output_file
      } 
    } catch { }
  }
  $Host.UI.RawUI.WindowTitle = "$nickname" + " - offline"
  $ChromeDriver.Quit()
  Write-Host "sleep for $waiting_time"
  Start-Sleep -seconds $waiting_time  
}

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