from graphql import GraphQLObjectType, GraphQLSchema, GraphQLField, GraphQLNonNull, GraphQLInt, GraphQLString, \
    GraphQLBoolean, GraphQLList, GraphQLArgument

from .nested_fixtures import getResource, getLink

'''
type Query { links(id: Int, ): [Link]} 
type Link { id: Int, url: String, resources(id: Int): [Resource] }
type Resource {id: Int, type: String, active: Boolean, cacheable: Boolean}

    {
        id: 1, url: "http://bit.com/xDerS",
        resources: [
            {id: 8901, type: "file", active: true, cacheable: true},
            {id: 8902, type: "file", active: false, cacheable: true}
        ]
    },
    {
        id: 2,
        url: "http://bit.com/aDeRe",
        resources: [{id: 8903, type: "file", active: true, cacheable: true}]
    }
'''

resourceType = GraphQLObjectType(
    "Resource",
    description="Set of url resources",
    fields=lambda: {
        "id": GraphQLField(
            GraphQLInt,
            description="The id of the resource"
        ),
        "type": GraphQLField(
            GraphQLString,
            description="The resource type",
        ),
        "active": GraphQLField(
            GraphQLBoolean,
            description="Flag to address if the resource is active"
        ),
        "cacheable": GraphQLField(
            GraphQLBoolean,
            description=""
        )
    },
)

linkType = GraphQLObjectType(
    "Link",
    description="Store url path and resources",
    fields=lambda: {
        "id": GraphQLField(
            GraphQLInt,
            description="The id of the link"
        ),
        "url": GraphQLField(
            GraphQLString,
            description="The url path"
        ),
        "resources": GraphQLField(
            GraphQLList(resourceType),
            args={
                "id": GraphQLArgument(
                    description="",
                    type=GraphQLString
                )
            },
            resolver=lambda root, info, **args: [getResource(args["id"])] if args.get("id") is not None else root["resources"]
        )
    }
)


queryType = GraphQLObjectType(
    "Query",
    fields=lambda: {
        "links": GraphQLField(
            GraphQLList(linkType),
            args={
                "id": GraphQLArgument(
                    description="The id of the link to look for",
                    type=GraphQLNonNull(GraphQLString)
                ),
            },
            resolver=lambda root, info, **args: [getLink(args["id"])],
        ),
        "resource": GraphQLField(
            GraphQLList(resourceType),
            args={
                "id": GraphQLArgument(
                    description="The id of the resource to look for",
                    type=GraphQLString
                )
            },
            resolver=lambda root, info, **args: getResource(args["id"]),
        )
    }
)

NestedSchema = GraphQLSchema(
    query=queryType
)

resourceOne = {
    "id": 8901,
    "type": "file",
    "active": True,
    "cacheable": True
}

resourceTwo = {
    "id": 8902,
    "type": "file",
    "active": False,
    "cacheable": True
}

resourceThree = {
    "id": 8903,
    "type": "file",
    "active": True,
    "cacheable": True
}

resourceList = {
    "8901": resourceOne,
    "8902": resourceTwo,
    "8903": resourceThree
}

linkOne = {
    "id": 1,
    "url": "http://bit.com/xDerS",
    "resources": [
        resourceOne,
        resourceTwo
    ]
}

linkTwo = {
    "id": 2,
    "url": "http://bit.com/aDeRe",
    "resources": [
        resourceThree
    ]
}


linkData = {
    "1": linkOne,
    "2": linkTwo,
}


def getLink(id):
    print(f'Link Data ID: {id}')
    print(linkData.get(id))
    return linkData.get(id)


def getResource(id):
    print(f'Resource Data ID: {id}')
    print(resourceList.get(id))
    return resourceList.get(id)

import pytest

from gql import Client, gql
from .nested_schema import NestedSchema


@pytest.fixture
def client():
    return Client(schema=NestedSchema)


def test_nested_query_without_nested_params(client):
    query = gql(
        """
        query getLinks($someId: String!){
            links(id: $someId) {
                id
                url
                resources {
                    id
                    type
                    active
                }
            }
        }
        """
    )
    params = {
        "someId": "1",
    }
    expected = {
        "links": [
            {
                'id': 1,
                'url': 'http://bit.com/xDerS',
                'resources': [
                    {'id': 8901, 'type': 'file', 'active': True},
                    {'id': 8902, 'type': 'file', 'active': False}
                ]
            }
        ]
    }
    result = client.execute(query, variable_values=params)
    print(result)
    assert result == expected


def test_nested_query_with_nested_params(client):
    query = gql(
        """
        query getLinks($linkId: String!, $resourceId: String!){
            links(id: $linkId) {
                id
                url
                resources(id: $resourceId) {
                    id
                    type
                    active
                }
            }
        }
        """
    )
    params = {
        "linkId": "1",
        "resourceId": "8902"
    }
    expected = {
        "links": [
            {
                'id': 1,
                'url': 'http://bit.com/xDerS',
                'resources': [
                    {'id': 8902, 'type': 'file', 'active': False}
                ]
            }
        ]
    }
    result = client.execute(query, variable_values=params)
    print(result)
    assert result == expected