# encoding: utf-8
"""Tests for IPython.utils.capture"""

# -----------------------------------------------------------------------------
#  Copyright (C) 2013 The IPython Development Team
#
#  Distributed under the terms of the BSD License.  The full license is in
#  the file COPYING, distributed as part of this software.
# -----------------------------------------------------------------------------

# -----------------------------------------------------------------------------
# Imports
# -----------------------------------------------------------------------------


import sys

import pytest

from IPython.utils import capture

# -----------------------------------------------------------------------------
# Globals
# -----------------------------------------------------------------------------

_mime_map = dict(
    _repr_png_="image/png",
    _repr_jpeg_="image/jpeg",
    _repr_svg_="image/svg+xml",
    _repr_html_="text/html",
    _repr_json_="application/json",
    _repr_javascript_="application/javascript",
)

basic_data = {
    "image/png": b"binarydata",
    "text/html": "<b>bold</b>",
}
basic_metadata = {
    "image/png": {
        "width": 10,
        "height": 20,
    },
}

full_data = {
    "image/png": b"binarydata",
    "image/jpeg": b"binarydata",
    "image/svg+xml": "<svg>",
    "text/html": "<b>bold</b>",
    "application/javascript": "alert();",
    "application/json": "{}",
}
full_metadata = {
    "image/png": {"png": "exists"},
    "image/jpeg": {"jpeg": "exists"},
    "image/svg+xml": {"svg": "exists"},
    "text/html": {"html": "exists"},
    "application/javascript": {"js": "exists"},
    "application/json": {"json": "exists"},
}

hello_stdout = "hello, stdout"
hello_stderr = "hello, stderr"


# -----------------------------------------------------------------------------
# Test Functions
# -----------------------------------------------------------------------------
@pytest.mark.parametrize("method_mime", _mime_map.items())
def test_rich_output_empty(method_mime):
    """RichOutput with no args"""
    rich = capture.RichOutput()
    method, mime = method_mime
    assert getattr(rich, method)() is None


def test_rich_output():
    """test RichOutput basics"""
    data = basic_data
    metadata = basic_metadata
    rich = capture.RichOutput(data=data, metadata=metadata)
    assert rich._repr_html_() == data["text/html"]
    assert rich._repr_png_() == (data["image/png"], metadata["image/png"])
    assert rich._repr_latex_() is None
    assert rich._repr_javascript_() is None
    assert rich._repr_svg_() is None


@pytest.mark.parametrize("method_mime", _mime_map.items())
def test_rich_output_no_metadata(method_mime):
    """test RichOutput with no metadata"""
    data = full_data
    rich = capture.RichOutput(data=data)
    method, mime = method_mime
    assert getattr(rich, method)() == data[mime]


@pytest.mark.parametrize("method_mime", _mime_map.items())
def test_rich_output_metadata(method_mime):
    """test RichOutput with metadata"""
    data = full_data
    metadata = full_metadata
    rich = capture.RichOutput(data=data, metadata=metadata)
    method, mime = method_mime
    assert getattr(rich, method)() == (data[mime], metadata[mime])


def test_rich_output_display():
    """test RichOutput.display

    This is a bit circular, because we are actually using the capture code we are testing
    to test itself.
    """
    data = full_data
    rich = capture.RichOutput(data=data)
    with capture.capture_output() as cap:
        rich.display()
    assert len(cap.outputs) == 1
    rich2 = cap.outputs[0]
    assert rich2.data == rich.data
    assert rich2.metadata == rich.metadata


def test_capture_output():
    """capture_output works"""
    rich = capture.RichOutput(data=full_data)
    with capture.capture_output() as cap:
        print(hello_stdout, end="")
        print(hello_stderr, end="", file=sys.stderr)
        rich.display()
    assert hello_stdout == cap.stdout
    assert hello_stderr == cap.stderr


def test_capture_output_no_stdout():
    """test capture_output(stdout=False)"""
    rich = capture.RichOutput(data=full_data)
    with capture.capture_output(stdout=False) as cap:
        print(hello_stdout, end="")
        print(hello_stderr, end="", file=sys.stderr)
        rich.display()
    assert "" == cap.stdout
    assert hello_stderr == cap.stderr
    assert len(cap.outputs) == 1


def test_capture_output_no_stderr():
    """test capture_output(stderr=False)"""
    rich = capture.RichOutput(data=full_data)
    # add nested capture_output so stderr doesn't make it to nose output
    with capture.capture_output(), capture.capture_output(stderr=False) as cap:
        print(hello_stdout, end="")
        print(hello_stderr, end="", file=sys.stderr)
        rich.display()
    assert hello_stdout == cap.stdout
    assert "" == cap.stderr
    assert len(cap.outputs) == 1


def test_capture_output_no_display():
    """test capture_output(display=False)"""
    data = full_data.copy()
    del data["image/png"]
    rich = capture.RichOutput(data=data)
    with capture.capture_output(display=False) as cap:
        print(hello_stdout, end="")
        print(hello_stderr, end="", file=sys.stderr)
        rich.display()
    assert hello_stdout == cap.stdout
    assert hello_stderr == cap.stderr
    assert cap.outputs == []


def test_captured_io_none_streams():
    """CapturedIO accepts None for stdout/stderr and returns empty strings."""
    cap = capture.CapturedIO(None, None)
    assert cap.stdout == ""
    assert cap.stderr == ""
    assert cap.outputs == []