"""Test localized sales sheets."""

import json

from flexmock import flexmock
from owslogger import logger
import pytest
from sqlalchemy.exc import SQLAlchemyError

from salessheets.connectors import mysql
from salessheets.constants import features
from tests.factories import template_details as template_factory
from tests.factories import vendor_default_template
from tests.test_utils import db


def test_get_vendor_template_rights_fail(client, valid_alw_headers):
    """Check that rights checked during get template request."""
    response = client.get(
        '/vendor/1/default_template', headers=valid_alw_headers)
    assert response.status_code == 403


def _seed_templates():
    other_template = template_factory.TemplateDetailsFactory()
    default_template = template_factory.TemplateDetailsFactory(
        is_default=True)
    db.seed_ss_models([other_template, default_template])
    return default_template, other_template


@db.test_schema
def test_get_vendor_template_return_default(client, mocker):
    """Check that handler returns default template is vendor is missed."""
    default_template, other_template = _seed_templates()
    mock = mocker.patch.object(logger.OwsLoggingAdapter, 'error')
    response = client.get('/vendor/1234/default_template')
    assert response.status_code == 200
    data = json.loads(response.data.decode())
    assert data['template_id'] == default_template.template_id
    mock.assert_called_with(
        'There is no default template for vendor 1234 found.')


@db.test_schema
def test_get_vendor_template_success(client, valid_alw_headers):
    """Test that handler returns vendor template if configured."""
    vendor_id = 1234
    default_template, other_template = _seed_templates()
    vendor_template = vendor_default_template.VendorDefaultTemplateFactory(
        vendor_id=vendor_id, template_details_id=other_template.template_id)
    db.seed_ss_models([vendor_template])
    response = client.get(
        '/vendor/{}/default_template'.format(vendor_id),
        headers=valid_alw_headers)
    assert response.status_code == 200
    data = json.loads(response.data.decode())
    assert data['template_id'] == other_template.template_id


@db.test_schema
def test_get_vendor_db_error(client):
    """Check that handler correctly processes DB exceptions."""
    flexmock(mysql).should_receive('ss_db_session').and_raise(SQLAlchemyError)
    response = client.get('/vendor/1234/default_template')
    assert response.status_code == 500
    data = json.loads(response.data.decode())
    assert data['code'] == 'internal_error'


@db.test_schema
def test_set_vendor_template_rights_fail(client, valid_alw_headers):
    """Check that rights checked during put template request."""
    response = client.put(
        '/vendor/1/default_template/1', headers=valid_alw_headers)
    assert response.status_code == 403


@db.test_schema
def test_set_vendor_template_no_template(client, valid_alw_headers):
    """Check that vendor template not set on unknown template_id."""
    vendor_id = 1234
    template_id = 1
    response = client.put(
        '/vendor/{}/default_template/{}'.format(vendor_id, template_id),
        headers=valid_alw_headers)
    assert response.status_code == 404


@db.test_schema
def test_set_vendor_template_success(client, valid_alw_headers):
    """Check that set vendor template works."""
    vendor_id = 1234
    default_template, other_template = _seed_templates()
    # set vendor template
    response = client.put(
        '/vendor/{}/default_template/{}'.format(
            vendor_id, default_template.template_id),
        headers=valid_alw_headers)
    assert response
    data = json.loads(response.data.decode())
    assert data['template_id'] == default_template.template_id
    assert data['vendor_id'] == vendor_id
    # get vendor template back to check that changes applied
    response = client.get('/vendor/{}/default_template'.format(vendor_id))
    assert response
    data = json.loads(response.data.decode())
    assert data['template_id'] == default_template.template_id
    # try to set other template to check that it can be changed
    response = client.put(
        '/vendor/{}/default_template/{}'.format(
            vendor_id, other_template.template_id))
    assert response
    data = json.loads(response.data.decode())
    assert data['template_id'] == other_template.template_id
    # get it again to check that new changes applied.
    response = client.get('/vendor/{}/default_template'.format(vendor_id))
    assert response
    data = json.loads(response.data.decode())
    assert data['template_id'] == other_template.template_id


@db.test_schema
def test_get_default_templates_success(client, feature_engine):
    """Test that get default_templates works."""
    default_template, other_template = _seed_templates()
    response = client.get('/default_templates')
    assert response.status_code == 200
    data = json.loads(response.data.decode())
    assert len(data) == 2
    assert data[0]['template_id'] == other_template.template_id
    assert data[1]['template_id'] == default_template.template_id
    assert 'template_name' in data[0]
    assert 'is_default' in data[0]


@db.test_schema
def test_get_default_templates_empty_db(client, feature_engine):
    """Test that get default_templates returns 404 on empty DB."""
    response = client.get('/default_templates')
    assert response.status_code == 404


@db.test_schema
@pytest.mark.parametrize('flag_state', [True, False])
def test_get_default_templates_europe(client, feature_engine, flag_state):
    """Test that europe feature flag works."""
    feature_engine.force_flag(
        features.LOCALIZED_SALES_SHEETS_EUROPE, flag_state)
    default_template, other_template = _seed_templates()
    eu_template = template_factory.TemplateDetailsFactory(
        name='EU', display_name='Europe', store_id=740,
        email='salesEU@theorchard.com', is_default=False)
    db.seed_ss_models([eu_template])
    response = client.get('/default_templates')
    assert response.status_code == 200
    data = json.loads(response.data.decode())
    assert len(data) == 3 if flag_state else 2
    assert data[0]['template_id'] == other_template.template_id
    assert data[1]['template_id'] == default_template.template_id
    if flag_state:
        assert data[2]['template_id'] == eu_template.template_id


@db.test_schema
@pytest.mark.parametrize('flag_state', [True, False])
def test_get_default_templates_japan(client, feature_engine, flag_state):
    """Test that japan feature flag works."""
    feature_engine.force_flag(
        features.JAPAN_SALES_SHEETS, flag_state)
    default_template, other_template = _seed_templates()
    jp_template = template_factory.TemplateDetailsFactory(
        name='JP', display_name='Japan', store_id=740,
        email='japan@theorchard.com', is_default=False)
    db.seed_ss_models([jp_template])
    response = client.get('/default_templates')
    assert response.status_code == 200
    data = json.loads(response.data.decode())
    assert len(data) == 3 if flag_state else 2
    assert data[0]['template_id'] == other_template.template_id
    assert data[1]['template_id'] == default_template.template_id
    if flag_state:
        assert data[2]['template_id'] == jp_template.template_id