#!/usr/bin/env python3
# Copyright (c) 2023 Intel Corporation
#
# SPDX-License-Identifier: Apache-2.0
"""
Tests for domains.py classes
"""

import mock
import os
import pytest
import sys

ZEPHYR_BASE = os.getenv("ZEPHYR_BASE")
sys.path.insert(0, os.path.join(ZEPHYR_BASE, "scripts/pylib/build_helpers"))

import domains

from contextlib import nullcontext


TESTDATA_1 = [
    ('', False, 1, ['domains.yaml file not found: domains.yaml']),
    (
"""
default: None
build_dir: some/dir
domains: []
""",
        True, None, []
    ),
]

@pytest.mark.parametrize(
    'f_contents, f_exists, exit_code, expected_logs',
    TESTDATA_1,
    ids=['no file', 'valid']
)
def test_from_file(caplog, f_contents, f_exists, exit_code, expected_logs):
    def mock_open(*args, **kwargs):
        if f_exists:
            return mock.mock_open(read_data=f_contents)(args, kwargs)
        raise FileNotFoundError(f'domains.yaml not found.')

    init_mock = mock.Mock(return_value=None)

    with mock.patch('domains.Domains.__init__', init_mock), \
         mock.patch('builtins.open', mock_open), \
         pytest.raises(SystemExit) if exit_code else nullcontext() as s_exit:
        result = domains.Domains.from_file('domains.yaml')

    if exit_code:
        assert str(s_exit.value) == str(exit_code)
    else:
        init_mock.assert_called_once()
        assert result is not None

    assert all([log in caplog.text for log in expected_logs])


TESTDATA_2 = [
    (
"""
default: some default
build_dir: my/dir
domains:
- name: some default
  build_dir: dir/2
- name: another
  build_dir: dir/3
flash_order: I don\'t think this is correct
""",
        1, None, None, None, None
    ),
    (
"""
build_dir: build/dir
domains:
- name: a domain
  build_dir: dir/1
- name: default_domain
  build_dir: dir/2
default: default_domain
flash_order:
- default_domain
- a domain
""",
        None,
        'build/dir',
        [('default_domain', 'dir/2'), ('a domain', 'dir/1')],
        ('default_domain', 'dir/2'),
        {'a domain': ('a domain', 'dir/1'),
         'default_domain': ('default_domain', 'dir/2')}
    ),
]

@pytest.mark.parametrize(
    'data, exit_code, expected_build_dir, expected_flash_order,' \
    ' expected_default, expected_domains',
    TESTDATA_2,
    ids=['invalid', 'valid']
)
def test_from_yaml(
    caplog,
    data,
    exit_code,
    expected_build_dir,
    expected_flash_order,
    expected_default,
    expected_domains
):
    def mock_domain(name, build_dir, *args, **kwargs):
        return name, build_dir

    with mock.patch('domains.Domain', side_effect=mock_domain), \
         pytest.raises(SystemExit) if exit_code else nullcontext() as exit_st:
        doms = domains.Domains.from_yaml(data)

    if exit_code:
        assert str(exit_st.value) == str(exit_code)
        return

    assert doms.get_default_domain() == expected_default
    assert doms.get_top_build_dir() == expected_build_dir

    assert doms._domains == expected_domains

    assert all([d in expected_flash_order for d in doms._flash_order])
    assert all([d in doms._flash_order for d in expected_flash_order])


TESTDATA_3 = [
    (
        None,
        True,
        [('some', os.path.join('dir', '2')),
         ('order', os.path.join('dir', '1'))]
    ),
    (
        None,
        False,
        [('order', os.path.join('dir', '1')),
         ('some', os.path.join('dir', '2'))]
    ),
    (
        ['some'],
        False,
        [('some', os.path.join('dir', '2'))]
    ),
]

@pytest.mark.parametrize(
    'names, default_flash_order, expected_result',
    TESTDATA_3,
    ids=['order only', 'no parameters', 'valid']
)
def test_get_domains(
    caplog,
    names,
    default_flash_order,
    expected_result
):
    doms = domains.Domains(
"""
domains:
- name: dummy
  build_dir: dummy
default: dummy
build_dir: dummy
"""
    )
    doms._flash_order = [
        ('some', os.path.join('dir', '2')),
        ('order', os.path.join('dir', '1'))
    ]
    doms._domains = {
        'order': ('order', os.path.join('dir', '1')),
        'some': ('some', os.path.join('dir', '2'))
    }

    result = doms.get_domains(names, default_flash_order)

    assert result == expected_result


TESTDATA_3 = [
    (
        'other',
        1,
        ['domain "other" not found, valid domains are: order, some'],
        None
    ),
    (
        'some',
        None,
        [],
        ('some', os.path.join('dir', '2'))
    ),
]

@pytest.mark.parametrize(
    'name, exit_code, expected_logs, expected_result',
    TESTDATA_3,
    ids=['domain not found', 'valid']
)
def test_get_domain(
    caplog,
    name,
    exit_code,
    expected_logs,
    expected_result
):
    doms = domains.Domains(
"""
domains:
- name: dummy
  build_dir: dummy
default: dummy
build_dir: dummy
"""
    )
    doms._flash_order = [
        ('some', os.path.join('dir', '2')),
        ('order', os.path.join('dir', '1'))
    ]
    doms._domains = {
        'order': ('order', os.path.join('dir', '1')),
        'some': ('some', os.path.join('dir', '2'))
    }

    with pytest.raises(SystemExit) if exit_code else nullcontext() as s_exit:
        result = doms.get_domain(name)

    assert all([log in caplog.text for log in expected_logs])

    if exit_code:
        assert str(s_exit.value) == str(exit_code)
    else:
        assert result == expected_result


def test_domain():
    name = 'Domain Name'
    build_dir = 'build/dir'

    domain = domains.Domain(name, build_dir)

    assert domain.name == name
    assert domain.build_dir == build_dir

    domain.name = 'New Name'
    domain.build_dir = 'new/dir'

    assert domain.name == 'New Name'
    assert domain.build_dir == 'new/dir'