"""Unit tests for StringEncrypt WebAPI client (HTTP mocked)."""

import zlib
import base64
from urllib.parse import parse_qs

import responses

from stringencrypt import StringEncrypt


API = StringEncrypt.API_URL


@responses.activate
def test_encrypt_success_plain_source():
    body = {"error": 0, "source": "print('ok')\n"}
    responses.add(responses.POST, API, json=body, status=200)

    se = StringEncrypt("", session=requests_session())
    se.enableCompression = False
    r = se.encrypt_string("hi", "lbl")
    assert r is not False
    assert r["error"] == 0
    assert r["error_string"] == "ERROR_SUCCESS"
    assert r["source"] == "print('ok')\n"


@responses.activate
def test_encrypt_success_compressed_source_roundtrip():
    plain = "decrypted source"
    compressed_field = base64.b64encode(
        zlib.compress(plain.encode("utf-8"), 9)
    ).decode("ascii")
    body = {"error": 0, "source": compressed_field}
    responses.add(responses.POST, API, json=body, status=200)

    se = StringEncrypt("", session=requests_session())
    se.enableCompression = True
    r = se.encrypt_string("hello", "lab")
    assert r is not False
    assert r["source"] == plain


@responses.activate
def test_http_error_returns_false():
    responses.add(responses.POST, API, status=500)
    se = StringEncrypt("", session=requests_session())
    assert se.encrypt_string("a", "b") is False


@responses.activate
def test_invalid_json_returns_false():
    responses.add(responses.POST, API, body="not json", status=200)
    se = StringEncrypt("", session=requests_session())
    assert se.encrypt_string("a", "b") is False


@responses.activate
def test_unknown_error_code_maps_to_unknown_string():
    body = {"error": 99999, "source": ""}
    responses.add(responses.POST, API, json=body, status=200)
    se = StringEncrypt("", session=requests_session())
    se.enableCompression = False
    r = se.encrypt_string("x", "y")
    assert r is not False
    assert r["error_string"] == "ERROR_UNKNOWN_99999"


@responses.activate
def test_info_command():
    body = {"engine_version": "v1.5.0", "supported_languages": [{"cpp": "C / C++"}]}
    responses.add(responses.POST, API, json=body, status=200)
    se = StringEncrypt("CODE", session=requests_session())
    r = se.info()
    assert r is not False
    assert r["engine_version"] == "v1.5.0"
    assert "error_string" not in r


@responses.activate
def test_encrypt_posts_include_flags():
    responses.add(responses.POST, API, json={"error": 0, "source": "x"}, status=200)
    se = StringEncrypt("", session=requests_session())
    se.enableCompression = False
    se.includeTags = True
    se.includeExample = True
    se.returnTemplate = True
    se.includeDebugComments = True
    se.highlight = "js"
    se.encryptionTemplate = '{"commands":[]}'
    se.encrypt_string("s", "l")

    assert len(responses.calls) == 1
    sent = responses.calls[0].request.body
    if isinstance(sent, bytes):
        sent = sent.decode("utf-8")
    q = parse_qs(sent, keep_blank_values=True)
    assert q.get("include_tags") == ["1"]
    assert q.get("include_example") == ["1"]
    assert q.get("return_template") == ["1"]
    assert q.get("include_debug_comments") == ["1"]
    assert q.get("highlight") == ["js"]
    assert "template" in q and q["template"]


def test_encrypt_file_empty(tmp_path):
    p = tmp_path / "empty.bin"
    p.write_bytes(b"")
    se = StringEncrypt("")
    assert se.encrypt_file_contents(p, "lbl") is False


def test_encrypt_file_reads_bytes(tmp_path, monkeypatch):
    p = tmp_path / "one.bin"
    p.write_bytes(b"\x00\xff")

    captured = {}

    def fake_post(self, params):
        captured["bytes"] = params.get("bytes")
        return {"error": 0, "source": ""}

    monkeypatch.setattr(StringEncrypt, "post_request", fake_post)
    se = StringEncrypt("")
    se.enableCompression = False
    se.encrypt_file_contents(p, "x")
    assert captured["bytes"] == b"\x00\xff"


def requests_session():
    import requests

    return requests.Session()


@responses.activate
def test_corrupt_compressed_source_returns_false():
    body = {"error": 0, "source": "not-valid-base64!!!"}
    responses.add(responses.POST, API, json=body, status=200)
    se = StringEncrypt("", session=requests_session())
    se.enableCompression = True
    assert se.encrypt_string("a", "b") is False