import json
import re

from urllib.parse import urlparse, urlunparse, urljoin
from streamlink.exceptions import PluginError, NoStreamsError
from streamlink.plugin.api import validate, useragents
from streamlink.plugin import Plugin, pluginmatcher
from streamlink.stream import HLSStream
from streamlink.utils import update_scheme

CONST_AMF_GATEWAY_LOCATION = '/tools/amf.php'
CONST_HEADERS = {'User-Agent': useragents.CHROME}

url_re = re.compile(r"(http(s)?://)?(([\w\-_]+)\.)?bongacams(\d*)\.com/([\w\-_]+)")

amf_msg_schema = validate.Schema({
    "status": "success",
    "userData": {"username": str},
    "localData": {"videoServerUrl": str},
    "performerData": {"username": str}
})

@pluginmatcher(url_re)
class bongacams(Plugin):
    def _get_streams(self):
        match = url_re.match(self.url)

        if not match:
            raise PluginError("Invalid URL format")

        stream_page_scheme = 'https'
        subdomain = match.group(4)
        base_domain = "bongacams99.com"
        stream_page_path = match.group(6)

        full_domain = f"{subdomain}.{base_domain}" if subdomain else base_domain
        initial_url = urlunparse((stream_page_scheme, full_domain, stream_page_path, '', '', ''))

        http_session = self.session.http
        http_session.headers.update(CONST_HEADERS)

        r = http_session.get(initial_url)

        if '/profile/' in r.url:
            raise NoStreamsError(self.url)
        if not r.ok:
            self.logger.debug("Status code for {0}: {1}", r.url, r.status_code)
            raise NoStreamsError(self.url)
        if len(http_session.cookies) == 0:
            raise PluginError("Can't get cookies")

        baseurl = urlunparse((stream_page_scheme, full_domain, '', '', '', ''))
        amf_gateway_url = urljoin(baseurl, CONST_AMF_GATEWAY_LOCATION)
        stream_page_url = urljoin(baseurl, stream_page_path)

        headers = {
            'User-Agent': useragents.CHROME,
            'Referer': stream_page_url,
            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
            'X-Requested-With': 'XMLHttpRequest'
        }

        data = f'method=getRoomData&args%5B%5D={stream_page_path}&args%5B%5D=false'
        self.logger.debug('DATA: {0}'.format(str(data)))
        r = http_session.post(url=amf_gateway_url, headers=headers, data=data)
        http_session.close()

        if r.status_code != 200:
            raise PluginError("Unexpected status code for {0}: {1}".format(r.url, r.status_code))

        try:
            response_json = json.loads(r.text)

            if response_json.get("status") == "error":
                self.logger.error("----- GEOBLOCK -----")
                return

            stream_source_info = amf_msg_schema.validate(response_json)
        except Exception as e:
            if 'videoServerUrl' not in r.text:
                self.logger.error("Stream is currently offline")
                return
            raise PluginError(f"Failed to validate response: {e}")

        self.logger.debug("Source stream info:\n{0}".format(stream_source_info))

        if not stream_source_info:
            return

        urlnoproto = stream_source_info['localData'].get('videoServerUrl')
        if not urlnoproto:
            self.logger.error("Stream is currently offline")
            return

        urlnoproto = update_scheme('https://', urlnoproto)
        performer = stream_source_info['performerData']['username']

        hls_url = f'{urlnoproto}/hls/stream_{performer}/playlist.m3u8'

        if hls_url:
            self.logger.debug('HLS URL: {0}'.format(hls_url))
            print('   HLS URL:', hls_url)
            print()
            try:
                for s in HLSStream.parse_variant_playlist(self.session, hls_url, headers=headers).items():
                    yield s
            except Exception as e:
                if '404' in str(e):
                    self.logger.error('Stream is currently offline or private')
                else:
                    self.logger.error(str(e))
                return


__plugin__ = bongacams

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
$username = Read-Host 'username'
$save_directory = 'D:\Records'
$default_stream = 'best'
$streamlink_exe = 'streamlink.exe'
$server = 'https://diana.dreamdares.com'
$user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
$address = 'https://dreamdares.com'
$waiting_time = 30 #seconds
$uri = "https://dreamdares.com/api/{0}/stream" -f $username
while($true) {
  Clear-Host
  $Host.UI.RawUI.WindowTitle = "$username (DreamDares)"
  $response = $null
  try {
    $response = Invoke-WebRequest -UseBasicParsing -TimeoutSec 60 -UserAgent $user_agent -Uri $uri
  } catch {
    $_.Exception.Message
    $uri
  }
  if ($response) {
    $json = $null
    $json = $response | ConvertFrom-Json
    if ($json) {
      $key = $json.key
      $active = $json.active
      if ($active -eq $true) {
        $stream_url = '{0}/publish/{1}/playlist.m3u8' -f $server, $key
        $date = Get-Date -f yyyy-MM-dd_HH-mm-ss
        $file_name = '{0}-{1}.ts' -f $username, $date
        $output = Join-Path $save_directory $file_name
        $Host.UI.RawUI.WindowTitle = "$username (DreamDares) - recording"
        & $streamlink_exe --http-header "User-Agent=$user_agent" --http-header "Referer=$address" --stream-segment-threads 3 --default-stream $default_stream --url $stream_url --output $output
      } else {
        $Host.UI.RawUI.WindowTitle = "$username (DreamDares) - offline"
        Write-Host "$username - offline"
      }
    }
  }
  Start-Sleep -seconds $waiting_time
}

$dir = "D:\Records"
$quality = "best"
$user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36"
$server = "https://diana.dreamdares.com"
$address = "https://dreamdares.com"
$waiting = 30

function Set-Title($text) {
    $host.UI.RawUI.WindowTitle = $text
    Clear-Host
    Write-Host "Dreamdares" -ForegroundColor Cyan
}

Set-Title "Request..."

$line= Read-Host "Enter URL or nickname"
$name = ($line.Trim() -replace '\?.*$', '' -replace '^.*\/', '')

$url_api = "$address/api/$name/stream"

function Get-StreamStatus {
    try {
        $response = Invoke-WebRequest -Uri $url_api -Headers @{"User-Agent" = $user_agent} -UseBasicParsing -ErrorAction Stop
        $json = $response.Content | ConvertFrom-Json
        if ([string]::IsNullOrEmpty($json.key) -or [string]::IsNullOrEmpty($json.active)) {
            return "_nickname_invalid_", "_nickname_invalid_"
        }
        return $json.key, $json.active
    }
    catch {
        if ($_.ErrorDetails -and $_.ErrorDetails.Message) {
            $errBody = $_.ErrorDetails.Message.Trim()
            try {
                $jsonError = $errBody | ConvertFrom-Json -ErrorAction Stop
                if ($jsonError.message -eq "could not get stream" -or $jsonError.message -eq "Invalid or expired JWT") {
                    return "_nickname_invalid_", "_nickname_invalid_"
                }
            } catch {}
        }
        return "_escaped_into_jungle_", "_escaped_into_jungle_"
    }
}

while ($true) {
    Set-Title "Checking status..."
    $key, $active = Get-StreamStatus

    if ($key -eq "_escaped_into_jungle_") {
        Set-Title "No response"
        Write-Host "No response from server." -ForegroundColor DarkYellow
        TIMEOUT /T $waiting
        continue
    }

    if ($key -eq "_nickname_invalid_") {
        Set-Title "$name - nickname invalid"
        Write-Host "$name - nickname invalid" -ForegroundColor Red
        Read-Host "Press ENTER to exit..."
        exit
    }

    if ($active -eq $false) {
        Set-Title "$name - offline"
        Write-Host "$name - OFFLINE" -ForegroundColor Yellow
        TIMEOUT /T $waiting
        continue
    }

    Set-Title "$name - rec"
    Write-Host "$name is ONLINE. Starting stream..." -ForegroundColor Green
    Write-Host ""

    $datetime = Get-Date -Format "yyyy-MM-dd_HH-mm-ss"
    $file = "${name}_DD_$datetime.ts"
    $stream_url = "$server/publish/$key/playlist.m3u8"

    streamlink `
        --http-header "User-Agent=$user_agent" `
        --http-header "Referer=$address" `
        --stream-segment-threads 3 `
        --url $stream_url `
        --default-stream $quality `
        --output "$dir\$file"

    TIMEOUT /T $waiting
}