"""Test for the cli componenets"""
# pylint: disable=redefined-outer-name, no-name-in-module, unused-import

import json

import pytest
import requests

import redfish_cli.cli
from redfish_cli import api
from redfish_cli.api import storage
from redfish_cli.api.exceptions import LogicalVolumeCreationFailure

from ..utils import get_test_json, MockResponse, MockRedfishResponse

from .test_cli import secrets


def test_create_logical_volume(capsys, monkeypatch):
    """Test the create-logical-volume command"""
    # pylint: disable=fixme, unused-argument, unused-variable
    # TODO: Write actual tests when the create-logical-volume code is fixed

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            "172.1.0.1",
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "password123",
            "logical",
            "create",
            "-c",
            "controller",
            "-d",
            "disk",
            "-r",
            "0",
        ]
    )
    monkeypatch.setattr(
        requests,
        "post",
        lambda args, auth=None, verify=None, data=None, headers=None, timeout=None: MockResponse(
            content="{}", headers={"Location": "/JOB12345"}
        ),
    )
    monkeypatch.setattr(redfish_cli.api, "firmware_version", lambda args: 2)

    redfish_cli.cli.create_logical_volume(args=args)
    captured = capsys.readouterr()
    result = captured.out
    assert "JOB12345" in result

    with pytest.raises(SystemExit):
        # pylint: disable=line-too-long
        monkeypatch.setattr(
            requests,
            "post",
            lambda args, auth=None, verify=None, data=None, headers=None, timeout=None: MockResponse(
                ok=False, content='{"msg":"and error occurred"}'
            ),
        )
        redfish_cli.cli.create_logical_volume(args=args)
        captured = capsys.readouterr()
        result = captured.err
        assert "JOB12345" in result

    with pytest.raises(SystemExit):
        args.raid_level = "zz"
        redfish_cli.cli.create_logical_volume(args=args)
        captured = capsys.readouterr()
        result = captured.err
        assert (
            "zz is not a valid raid level. Valid choices are 0,1,5,10,50"
            in result
        )


def test_delete_logical_volume(capsys, monkeypatch):
    """Test the create-logical-volume command"""
    # pylint: disable=fixme, unused-argument, unused-variable
    # TODO: Write actual tests when the create-logical-volume code is fixed

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            "172.1.0.1",
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "password123",
            "logical",
            "create",
            "-c",
            "controller",
            "-d",
            "disk",
            "-r",
            "0",
        ]
    )
    monkeypatch.setattr(
        requests,
        "delete",
        lambda args, auth=None, verify=None, data=None, headers=None, timeout=None: MockResponse(
            content="{}", headers={"Location": "/JOB12345"}
        ),
    )
    monkeypatch.setattr(redfish_cli.api, "firmware_version", lambda args: 2)

    redfish_cli.cli.delete_logical_volume(args=args)
    captured = capsys.readouterr()
    result = captured.out
    assert "JOB12345" in result

    with pytest.raises(SystemExit):
        # pylint: disable=line-too-long
        monkeypatch.setattr(
            requests,
            "delete",
            lambda args, auth=None, verify=None, data=None, headers=None, timeout=None: MockResponse(
                ok=False, content='{"msg":"and error occurred"}'
            ),
        )
        redfish_cli.cli.delete_logical_volume(args=args)
        captured = capsys.readouterr()
        result = captured.err
        assert "JOB12345" in result

    with pytest.raises(SystemExit):
        args.raid_level = "zz"
        redfish_cli.cli.create_logical_volume(args=args)
        captured = capsys.readouterr()
        result = captured.err
        assert (
            "zz is not a valid raid level. Valid choices are 0,1,5,10,50"
            in result
        )


def test_show_logical_volume(capsys, monkeypatch):
    """Test the cli logical-volume command"""
    _json = get_test_json("cli_logical_volume.json")
    monkeypatch.setattr(
        requests,
        "get",
        lambda *args, **kwargs: MockResponse(
            content=json.dumps(_json), status_code=200
        ),
    )
    args = redfish_cli.cli.parse_args(
        [
            "-s",
            "172.1.0.1",
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "password123",
            "logical",
            "show",
            "-d",
            "Disk.Virtual.0:RAID.Slot.6-1",
        ]
    )
    redfish_cli.cli.redfish(args=args)
    result = json.loads(capsys.readouterr().out)
    assert result["Id"] == "Disk.Virtual.0:RAID.Slot.6-1"

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            "172.1.0.1",
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "password123",
            "logical",
            "show",
        ]
    )

    monkeypatch.setattr(
        redfish_cli.api.storage,
        "list_storage_controllers",
        lambda *args, **kwargs: {
            "Members": [
                {
                    "@odata.id": "/redfish/v1/Systems/System.Embedded.1/Storage/RAID.Slot.6-1"
                }
            ]
        },
    )

    monkeypatch.setattr(
        redfish_cli.api.storage,
        "list_logical_volumes",
        lambda *args, **kwargs: {
            "Members": [
                {
                    "@odata.id": "/redfish/v1/Systems/System.Embedded.1/"
                    "Storage/Volumes/Disk.Virtual.0:RAID.Slot.6-1"
                },
                {
                    "@odata.id": "/redfish/v1/Systems/System.Embedded.1"
                    "/Storage/Volumes/Disk.Virtual.1:RAID.Slot.6-1"
                },
            ]
        },
    )

    redfish_cli.cli.redfish(args=args)
    result = json.loads(capsys.readouterr().out)
    assert result["Id"] == "Disk.Virtual.0:RAID.Slot.6-1"

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            "172.1.0.1",
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "password123",
            "logical",
            "show",
            "-c",
            "RAID.Slot.6-1",
        ]
    )

    redfish_cli.cli.redfish(args=args)
    result = json.loads(capsys.readouterr().out)
    assert result["Id"] == "Disk.Virtual.0:RAID.Slot.6-1"

    monkeypatch.setattr(
        requests,
        "get",
        lambda *args, **kwargs: MockResponse(
            ok=False, content='"Invalid logical volume"'
        ),
    )
    try:
        redfish_cli.cli.redfish(args=args)
    except SystemExit:
        result = capsys.readouterr().err
        assert result == '"Invalid logical volume"\n'


def test_list_logical_volumes(capsys, monkeypatch):
    """Test the cli logical-volumes command"""
    _json = get_test_json("cli_logical_volumes.json")

    monkeypatch.setattr(
        requests,
        "get",
        lambda *args, **kwargs: MockResponse(
            content=json.dumps(_json), status_code=200
        ),
    )

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            "172.1.0.1",
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "password123",
            "logical",
            "list",
            "-c",
            "RAID.Slot.6-1",
        ]
    )
    redfish_cli.cli.redfish(args=args)
    # err_out = capsys.readouterr().out
    result = json.loads(capsys.readouterr().out)
    assert result["Name"] == "Volume Collection"

    monkeypatch.setattr(
        requests,
        "get",
        lambda *args, **kwargs: MockResponse(ok=False, content='"Invalid"'),
    )
    try:
        redfish_cli.cli.redfish(args=args)
    except SystemExit:
        result = capsys.readouterr().err
        assert result == '"Invalid"\n'


def test_show_phsyical_volume(capsys, monkeypatch, secrets):
    """Test the physical_voume cli command"""

    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("physical_volume.json")
        return MockResponse(status_code=200, content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)
    monkeypatch.setattr(
        storage,
        "list_storage_controllers",
        lambda *args, **kwargs: {"Members": [{"@odata.id": ""}]},
    )
    monkeypatch.setattr(
        storage,
        "list_physical_volumes",
        lambda *args, **kwargs: [{"drive": "Dummy"}],
    )
    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "physical",
            "show",
        ]
    )
    redfish_cli.cli.physical_volume(args)
    captured = capsys.readouterr()
    result = json.loads(captured.out)
    assert result["CapacityBytes"] == 299439751168


def test_list_phsyical_volumes(capsys, monkeypatch, secrets):
    """Test the physical_voume cli command"""

    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("physical_volumes.json")
        return MockResponse(status_code=200, content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)
    monkeypatch.setattr(
        storage,
        "list_storage_controllers",
        lambda *args, **kwargs: {"Members": [{"@odata.id": ""}]},
    )

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "physical",
            "list",
        ]
    )
    redfish_cli.cli.physical_volumes(args)
    captured = capsys.readouterr()
    result = json.loads(captured.out)
    assert (
        result[0]["drive"] == "Disk.Bay.0:Enclosure.Internal.0-1:RAID.Slot.6-1"
    )

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "text",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "physical",
            "list",
            "-c",
            "Storage.Controller.1",
        ]
    )
    redfish_cli.cli.physical_volumes(args)
    captured = capsys.readouterr()
    result = captured.out
    assert (
        "System.Embedded.1 Disk.Bay.0:Enclosure.Internal.0-1:RAID.Slot.6-1\n"
        in result
    )

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "table",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "physical",
            "list",
            "-c",
            "Storage.Controller.1",
        ]
    )
    redfish_cli.cli.physical_volumes(args)
    captured = capsys.readouterr()
    result = captured.out
    assert result.startswith("+-------------------+-------------------------")
    assert "| Disk.Bay.0:Enclosure.Internal.0-1:RAID.Slot.6-1 |" in result

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-v",
            "-f",
            "table",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "physical",
            "list",
            "-c",
            "Storage.Controller.1",
        ]
    )
    redfish_cli.cli.physical_volumes(args)
    captured = capsys.readouterr()
    result = captured.out
    assert result.startswith("+-------------------+-------------------------")
    assert "| System.Embedded.1 | Disk.Bay.0:Enclosure.Internal.0-" in result


def test_storage_controller(capsys, monkeypatch, secrets):
    """Test the storage-controller cli command"""

    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("storage_controller.json")
        return MockResponse(status_code=200, content=mock_redfish.text)

    monkeypatch.setattr(requests, "get", mock_get)
    monkeypatch.setattr(
        api.storage,
        "list_storage_controllers",
        lambda *args, **kwargs: {"Members": [{"@odata.id": "/"}]},
    )

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "controllers",
            "show",
        ]
    )
    redfish_cli.cli.storage_controller(args)
    captured = capsys.readouterr()
    result = json.loads(captured.out)
    assert result["Id"] == "RAID.Slot.6-1"

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "text",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "controllers",
            "show",
            "-c",
            "RAID.Slot.6-1",
        ]
    )
    redfish_cli.cli.storage_controller(args)
    captured = capsys.readouterr()
    result = captured.out
    # Currently returns JSON(ish) will need to update test later
    assert "'Id': 'RAID.Slot.6-1'" in result

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "table",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "controllers",
            "show",
            "-c",
            "RAID.Slot.6-1",
        ]
    )
    redfish_cli.cli.storage_controller(args)
    captured = capsys.readouterr()
    result = captured.out
    # Currently returns JSON(ish) will need to update test later
    assert "'Id': 'RAID.Slot.6-1'" in result

    monkeypatch.setattr(
        requests,
        "get",
        lambda *args, **kwargs: MockResponse(
            ok=False, content='"Invalid storage controller"'
        ),
    )
    try:
        redfish_cli.cli.redfish(args=args)
    except SystemExit:
        result = capsys.readouterr().err
        assert result == '"Invalid storage controller"\n'


def test_list_storage_controllers(capsys, monkeypatch, secrets):
    """Test the storage-controllers cli command"""

    def mock_get(*args, **kwargs):
        # pylint: disable=unused-argument
        mock_redfish = MockRedfishResponse()
        mock_redfish.json_dict = get_test_json("cli_storage_controllers.json")
        return MockResponse(status_code=200, content=mock_redfish.text)

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

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "json",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "controllers",
            "list",
        ]
    )
    redfish_cli.cli.storage_controllers(args)
    captured = capsys.readouterr()
    result = json.loads(captured.out)
    assert result == ["RAID.Slot.6-1"]

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "text",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "controllers",
            "list",
        ]
    )
    redfish_cli.cli.storage_controllers(args)
    captured = capsys.readouterr()
    result = captured.out
    assert result == "RAID.Slot.6-1\n"

    args = redfish_cli.cli.parse_args(
        [
            "-s",
            secrets["server"],
            "-f",
            "table",
            "storage",
            "-u",
            "root",
            "-p",
            "dummy",
            "controllers",
            "list",
        ]
    )
    redfish_cli.cli.storage_controllers(args)
    captured = capsys.readouterr()
    result = captured.out
    assert result == (
        "+---------------+\n| Controller    |\n+===============+\n| "
        "RAID.Slot.6-1 |\n+---------------+\n"
    )