"""
Tests of the api
"""
import argparse
import json

import pytest

import requests

import redfish_cli.api
import redfish_cli.api.storage
import redfish_cli.api.systems
from redfish_cli.api.exceptions import (
    ResponseNotOK,
    Unauthorized,
)

from ..utils import get_test_json, MockRedfishResponse, MockResponse


# pylint: disable=missing-function-docstring,redefined-outer-name


@pytest.fixture
def secrets():
    return {"server": "idrac-01", "username": "root", "password": "secrete"}


def test_chassis(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("api_chassis.json")
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)

    chassis = redfish_cli.api.chassis(**secrets)
    assert chassis["Name"] == "Chassis Collection"


def test_chassis_details(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("api_chassis_details.json")
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)

    secrets.update({"chassis": "System.Embedded.1"})
    chassis_details = redfish_cli.api.chassis_details(**secrets)
    assert chassis_details["Name"] == "Computer System Chassis"


def test_get_base_redfish(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)
    _ = redfish_cli.api.utils.get(secrets["server"], "")
    assert "@odata.id" in redfish_cli.api.utils.get(secrets["server"], "")

    monkeypatch.setattr(
        requests, "get", lambda *args, **kwargs: MockResponse(ok=False)
    )
    with pytest.raises(ResponseNotOK):
        _ = redfish_cli.api.utils.get(secrets["server"], "")


def test_invalid_json(monkeypatch, secrets):
    """Test processing of invalid json returned from a get"""

    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        return MockResponse(content="{'a':'invalid json'}")

    monkeypatch.setattr(requests, "get", mock_get)
    secrets.update({"url": "/"})

    with pytest.raises(json.decoder.JSONDecodeError):
        _ = redfish_cli.api.utils.get(**secrets)


def test_post(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        _json = {"@odata.id": "dummy"}
        return MockResponse(content=json.dumps(_json))

    monkeypatch.setattr(requests, "post", mock_get)
    _ = redfish_cli.api.utils.post(secrets["server"], "")
    assert (
        "@odata.id"
        in redfish_cli.api.utils.post(
            secrets["server"], "", username="test", password="test"
        ).json()
    )

    monkeypatch.setattr(
        requests, "post", lambda *args, **kwargs: MockResponse(status_code=401)
    )
    with pytest.raises(Unauthorized):
        _ = redfish_cli.api.utils.post(secrets["server"], "")

    monkeypatch.setattr(
        requests, "post", lambda *args, **kwargs: MockResponse(ok=False)
    )
    with pytest.raises(ResponseNotOK):
        _ = redfish_cli.api.utils.post(secrets["server"], "")

    monkeypatch.setattr(
        requests,
        "post",
        lambda *args, **kwargs: MockResponse(content="Invalid json"),
    )


def test_product(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)

    assert (
        redfish_cli.api.product(secrets["server"])
        == "Integrated Dell Remote Access Controller"
    )


def test_response_not_ok():
    try:
        raise ResponseNotOK
    except ResponseNotOK as exc:
        assert exc.response is None


def test_service_tag(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)
    assert "JYYZY42" in redfish_cli.api.service_tag(secrets["server"])

    def mock_get_hp(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict["Oem"] = {"HPE": {}}
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get_hp)
    with pytest.raises(redfish_cli.api.exceptions.DellOnly):
        assert "JYYZY42" in redfish_cli.api.service_tag(secrets["server"])


def test_system_details(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("system_details.json")
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)

    assert (
        "/redfish/v1/Systems/System.Embedded.1"
        == redfish_cli.api.systems.system_details(
            secrets["server"],
            secrets["username"],
            secrets["password"],
            "System.Embedded.1",
        )["@odata.id"]
    )


def test_unauthorized(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        return MockResponse(status_code=401, content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)
    secrets.update({"url": "/"})

    with pytest.raises(redfish_cli.api.exceptions.Unauthorized):
        _ = redfish_cli.api.utils.get(**secrets)


def test_version(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)

    assert redfish_cli.api.redfish_version(secrets["server"]) == "1.4.0"


def test_manager(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("api_manager.json")
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)

    args = argparse.Namespace()
    args.server = secrets["server"]
    args.username = secrets["username"]
    args.password = secrets["password"]
    args.manager = None

    assert (
        redfish_cli.api.manager(args)["@odata.id"]
        == "/redfish/v1/Managers/iDRAC.Embedded.1"
    )

    args = argparse.Namespace()
    args.server = secrets["server"]
    args.username = secrets["username"]
    args.password = secrets["password"]

    assert (
        redfish_cli.api.manager(args)["@odata.id"]
        == "/redfish/v1/Managers/iDRAC.Embedded.1"
    )


def test_firmware_version(monkeypatch, secrets):
    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("api_manager.json")
        return MockResponse(content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)

    args = argparse.Namespace()
    args.server = secrets["server"]
    args.username = secrets["username"]
    args.password = secrets["password"]
    args.manager = None

    assert redfish_cli.api.firmware_version(args) == 2656565