import jsonschema

from resource_management.routes.default import Version
from resource_management.routes import interfaces
from resource_management import router_interfaces
from resource_management import db
from resource_management.db import model

import pytest


def test_bad_method(client):
    rv = client.post('/api/version')
    assert rv.status_code == 405


def test_version_request(client):
    rv = client.get('/api/version')
    assert rv.status_code == 200
    jsonschema.validate(rv.json(), Version.schema())


def test_update_router_interfaces(
        client, resources_db, mocked_router, router_name):
    rv = client.post(f'/api/interfaces/initialize-router/{router_name}')
    assert rv.status_code == 200
    jsonschema.validate(rv.json(), interfaces.InterfacesSummary.schema())


def test_next_lag(client, resources_db, mocked_router, router_name):

    router_interfaces.load_new_router_interfaces(router_name)

    rv = client.post(f'/api/interfaces/next-lag/{router_name}')
    assert rv.status_code == 200
    response = rv.json()
    jsonschema.validate(response, interfaces.NextLAG.schema())

    with db.session_scope() as session:
        row = session.query(model.LAG). \
            filter_by(name=response['name']). \
            join(model.Router). \
            filter_by(fqdn=router_name).one()
        assert row.availability == model.AvalabilityStates.RESERVED.name


def test_next_physical(client, resources_db, mocked_router, router_name):

    if '.lab.' in router_name:
        pytest.skip('not all lab routers have available ports')
    if router_name.startswith('rt'):
        pytest.skip('not all rt* have available ports')

    router_interfaces.load_new_router_interfaces(router_name)

    with db.session_scope() as session:
        rows = session.query(model.LAG.name). \
            join(model.Router). \
            filter_by(fqdn=router_name).all()
        lag_name = rows[0][0]

    rv = client.post(f'/api/interfaces/next-physical/{router_name}/{lag_name}')
    assert rv.status_code == 200

    response = rv.json()
    jsonschema.validate(response, interfaces.NextPhysicalInterface.schema())

    assert response['fqdn'] == router_name
    assert response['lag'] == lag_name

    with db.session_scope() as session:
        ifc_row = session.query(model.PhysicalInterface). \
            filter_by(name=response['name']). \
            join(model.Router). \
            filter_by(fqdn=router_name). \
            join(model.LAG). \
            filter_by(name=lag_name).one()
        assert ifc_row.availability == model.AvalabilityStates.RESERVED.name


def test_list_of_routers(client, resources_db):

    with db.session_scope() as session:
        for idx in range(10):
            row = db.model.Router(fqdn=f'router-{idx}.xyz.com')
            session.add(row)

    rv = client.get('/api/interfaces/routers')
    assert rv.status_code == 200

    response = rv.json()
    jsonschema.validate(response, interfaces.ListOfRouters.schema())
    for r in response['routers']:
        assert r['fqdn'].endswith('.xyz.com')