# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright (c) 2016, Anaconda, Inc. All rights reserved.
#
# Licensed under the terms of the BSD 3-Clause License.
# The full license is in the file LICENSE.txt, distributed with this software.
# -----------------------------------------------------------------------------
from __future__ import absolute_import

from anaconda_project.conda_manager import (push_conda_manager_class, pop_conda_manager_class, new_conda_manager,
                                            CondaManager, CondaLockSet)
import anaconda_project.internal.conda_api as conda_api
from anaconda_project.yaml_file import _dump_string


def test_use_non_default_conda_manager():
    called = dict()

    class MyCondaManager(CondaManager):
        def __init__(self, frontend):
            pass

        def resolve_dependencies(self, package_specs, channels, platforms):
            return CondaLockSet({}, platforms=[])

        def find_environment_deviations(self, *args):
            called['find_environment_deviations'] = args

        def fix_environment_deviations(self, *args):
            called['fix_environment_deviations'] = args

        def remove_packages(self, *args):
            called['remove_packages'] = args

    push_conda_manager_class(MyCondaManager)
    try:
        manager = new_conda_manager()
        manager.find_environment_deviations(None, None)
        manager.fix_environment_deviations(None, None)
        manager.remove_packages(None, None)
        assert dict(find_environment_deviations=(None, None),
                    fix_environment_deviations=(None, None),
                    remove_packages=(None, None)) == called
    finally:
        pop_conda_manager_class()


def test_lock_set_properties(monkeypatch):
    lock_set = CondaLockSet(
        {
            'all': ["something=0.5=2", "bokeh=0.12.4=1"],
            'linux-64': ["linux-thing=1.0=0"],
            'unix': ["unix-thing=5=1"],
            'win': ["windows-cross-bit-thing=3.2"],
            'win-32': ["windows-thing=2.0=3", "bokeh=2.3=7"]
        },
        platforms=['linux-64', 'win-32'])
    # it is part of the API definition that we need to APPEND the
    # per-platform stuff, so it overrides.
    assert lock_set.package_specs_for_platform('win-32') == ("something=0.5=2", "windows-cross-bit-thing=3.2",
                                                             "windows-thing=2.0=3", "bokeh=2.3=7")

    # on Linux-64, test that it works without monkeypatch
    if conda_api.current_platform() != 'linux-64':
        monkeypatch.setattr('anaconda_project.internal.conda_api.current_platform', lambda: 'linux-64')

    assert lock_set.package_specs_for_current_platform == ("something=0.5=2", "bokeh=0.12.4=1", "unix-thing=5=1",
                                                           "linux-thing=1.0=0")

    assert lock_set.platforms == ('linux-64', 'win-32')


def test_lock_set_to_json(monkeypatch):
    lock_set = CondaLockSet(
        {
            'all': ["something=0.5=2", "bokeh=0.12.4=1"],
            'linux-64': ["linux-thing=1.0=0"],
            'win-32': ["windows-thing=2.0=3", "bokeh=2.3=7"]
        },
        platforms=['linux-64', 'win-32'])
    assert {
        'locked': True,
        'packages': {
            'all': ['something=0.5=2', 'bokeh=0.12.4=1'],
            'linux-64': ['linux-thing=1.0=0'],
            'win-32': ['windows-thing=2.0=3', 'bokeh=2.3=7']
        },
        'platforms': ['linux-64', 'win-32']
    } == lock_set.to_json()


def test_lock_set_to_yaml(monkeypatch):
    lock_set = CondaLockSet({
        'all': ['a', 'b'],
        'linux': ['x'],
        'win': ['y'],
        'linux-64': ['z', 'q'],
        'osx-64': ['s']
    },
                            platforms=['linux-64', 'win-64', 'osx-64'])

    # Mostly our interest here is that the ordering of the dict
    # is deterministic
    j = lock_set.to_json()
    assert _dump_string(j) == """locked: true
platforms:
- linux-64
- osx-64
- win-64
packages:
  all:
  - a
  - b
  linux:
  - x
  win:
  - y
  linux-64:
  - z
  - q
  osx-64:
  - s
"""


def test_lock_set_diff_and_equivalent():
    old_lock_set = CondaLockSet(
        {
            'all': ['a', 'b'],
            'linux': ['x'],
            'win': ['y'],
            'linux-64': ['z', 'q'],
            'osx-64': ['s']
        },
        platforms=['linux-64', 'osx-64'])
    new_lock_set = CondaLockSet(
        {
            'all': ['a', 'b', 'c'],
            'linux': ['x', 'h'],
            'win': ['y'],
            'linux-64': ['q', 'w'],
            'osx-64': ['s'],
            'win-64': ['j']
        },
        platforms=['linux-64', 'win-64'])

    assert """  platforms:
-   osx-64
+   win-64
  packages:
    all:
+     c
    linux:
+     h
    linux-64:
-     z
+     w
+   win-64:
+     j""" == new_lock_set.diff_from(old_lock_set)

    assert """  platforms:
-   win-64
+   osx-64
  packages:
    all:
-     c
    linux:
-     h
    linux-64:
+     z
-     w
-   win-64:
-     j""" == old_lock_set.diff_from(new_lock_set)

    assert "" == new_lock_set.diff_from(new_lock_set)
    assert "" == old_lock_set.diff_from(old_lock_set)

    assert old_lock_set.equivalent_to(old_lock_set)
    assert new_lock_set.equivalent_to(new_lock_set)
    assert not old_lock_set.equivalent_to(new_lock_set)
    assert not new_lock_set.equivalent_to(old_lock_set)

    assert """  platforms:
+   linux-64
+   win-64
  packages:
+   all:
+     a
+     b
+     c
+   linux:
+     x
+     h
+   win:
+     y
+   linux-64:
+     q
+     w
+   osx-64:
+     s
+   win-64:
+     j""" == new_lock_set.diff_from(None)