# standard imports
import json
import logging
import sys
import uuid

import redis
from cic_eth.api.api_task import Api
from cic_eth.graphql.config import config
from graphene import (Boolean, Field, Float, Int, List, Mutation, ObjectType,
                      Schema, String)

chain_spec = config.get('CHAIN_SPEC')
redis_host = config.get('REDIS_HOST')
redis_port = config.get('REDIS_PORT')
redis_db = config.get('REDIS_DB')
celery_queue = config.get('CELERY_QUEUE')

logging.basicConfig(level=logging.DEBUG)

log = logging.getLogger(__name__)




def call(method, *args):
    redis_channel = str(uuid.uuid4())
    r = redis.Redis(redis_host, redis_port, redis_db)
    ps = r.pubsub()
    ps.subscribe(redis_channel)
    ps.get_message()  # Subscription Object
    print(f"Channel init {redis_channel}")
    print(args)
    api = Api(
        chain_spec,
        queue=celery_queue,
        callback_param='{}:{}:{}:{}'.format(
            redis_host, redis_port, redis_db, redis_channel),
        callback_task='cic_eth.callbacks.redis.redis',
        callback_queue=celery_queue,
    )
    getattr(api, method)(*args)

    ps.get_message()  # returns None !?
    try:
        o = ps.get_message(timeout=config.get('REDIS_TIMEOUT'))
    except TimeoutError as e:
        sys.stderr.write(
            'got no new address from cic-eth before timeout: {}\n'.format(e))
        sys.exit(1)
    ps.unsubscribe()
    print(o)
    m = json.loads(o['data'])
    return m["result"]


class Token(ObjectType):
    symbol = String()
    address = String()
    name = String()
    decimals = Int()


class TokenBalance(ObjectType):
    address = String()
    converters = List(String)
    balance_network = String(default_value="0")
    balance_incoming = String(default_value="0")
    balance_outgoing = String(default_value="0")
    balance_available = String(default_value="0")

    def resolve_balance_available(parent, info):
        print(parent)
        return str(int(parent.balance_network) + int(parent.balance_incoming) - int(parent.balance_outgoing))



class Query(ObjectType):
    default_token = Field(Token)

    def resolve_default_token(parent, info):

        # always pass an object for `me` field
        api = Api(
            chain_spec,
            queue=celery_queue,
        )
        task = api.default_token()
        data = task.get()
        print(data)
        return Token(**data)

    balance = Field(List(TokenBalance), address=String(),
                    token_symbol=String(), include_pending=Boolean())

    def resolve_balance(root, info, address, token_symbol, include_pending=True):
        api = Api(
            chain_spec,
            queue=celery_queue,
        )
        task = api.balance(address=address, token_symbol=token_symbol, include_pending=include_pending)
        data = task.get() #api call('balance', address, token_symbol, include_pending)
        log.debug(data)
        print(data, file=sys.stdout)
        #[{'address': '3ff776b6f888980def9d4220858803f9dc5e341e', 'converters': [], 'balance_network': 0}]
        return map(lambda token: TokenBalance(
            address=token.get("address"),
            converters=token.get("converters"),
            balance_network=str(token.get("balance_network") or "0"),
            balance_incoming=str(token.get("balance_incoming") or "0"),
            balance_outgoing=str(token.get("balance_outgoing") or "0"),
            balance_available=str(token.get("balance_available" or "0"))
        ), data)

    transactions = Field(String, address=String(
        required=True), limit=Int(default_value=10))

    def resolve_transactions(root, info, address, limit):

        api = Api(
            chain_spec,
            queue=celery_queue,
        )
        task = api.list(address=address, limit=limit)
        data = task.get()
        print(data)
        #[{'address': '3ff776b6f888980def9d4220858803f9dc5e341e', 'converters': [], 'balance_network': 0}]
        return "test"


class CreateAccount(Mutation):
    address = String()

    class Arguments:
        password = String(required=True)
        register = Boolean()

    def mutate(root, info, password, register=True):
        print(password, register)
        api = Api(
            chain_spec,
            queue=celery_queue,
        )
                
        address = call('create_account',password, register)
        return CreateAccount(address=f"0x{address}")


class Transfer(Mutation):
    test = String(default_value="test")

    class Arguments:
        from_address = String(required=True)
        to_address = String(required=True)
        value = Int(required=True)
        token_symbol = String(required=True)

    def mutate(root, info, from_address,
               to_address,
               value,
               token_symbol):
        print(from_address, to_address, value, token_symbol)
        api = Api(
            chain_spec,
            queue=celery_queue,
        )
        t = api.transfer(from_address, to_address,
                         int(value * (10**6)), token_symbol)
        print(f"t {t}")
        print(f"transfer {t.get_leaf()}")
        print(f"transfer {t.successful()}")
        return t.get()
# 0x0000000000000000000000000000000000000000


class TransferFrom(Mutation):
    address = String()

    class Arguments:
        from_address = String(required=True)
        to_address = String(required=True)
        value = Int(required=True)
        token_symbol = String(required=True)
        spender_address = String(required=True)

    def mutate(root, info, from_address,
               to_address,
               value,
               token_symbol, spender_address):
        api = Api(
            chain_spec,
            queue=celery_queue,
        )
        task = api.transfer_from(from_address=from_address,
                    to_address=to_address,
                    value=value,
                    token_symbol=token_symbol, spender_address=spender_address)
        return task.get()


class MyMutations(ObjectType):
    create_account = CreateAccount.Field()
    transfer = Transfer.Field()


schema = Schema(query=Query, mutation=MyMutations)


query_with_argument = """
{ 
  defaultToken{
    symbol
  } 
}

"""
# result = schema.execute(query_with_argument)
# print(result)


mutation_with_argument = """
mutation { 
  createAccount(password:"test"){
    address
  }
}

"""
m_result = schema.execute(mutation_with_argument)
print(m_result.data)
address_1 = "0xde82da08c816865c24a2c9c76a2bcd44b5b94531" #m_result.data['createAccount']['address']

mutation_with_argument = """
mutation { 
  createAccount(password:"test"){
    address
  }
}

"""
m_result = schema.execute(mutation_with_argument)
print(m_result)
address_2 = "0xaee24c8af3249b2d0a26769286623fff00556788"  #m_result.data['createAccount']['address']

balance_query = """
query getBalance($address:String){ 
  balance(address: $address, tokenSymbols:["COFE"]){
    balanceNetwork
    balanceIncoming
    balanceOutgoing
    balanceAvailable
  }
}

"""
balance_query_result = schema.execute(
    balance_query, variables={"address": "address_1"})
# print(balance_query_result)


transfer_mutation = """
mutation transfer($from: String, $to: String) { 
  transfer(fromAddress : $from,
toAddress:  $to
value: 20
tokenSymbol: "COFE" ){
    test
  }
}

"""
transfer_mutation_result = schema.execute(transfer_mutation, variables={
                                          "from": address_1, "to": address_2})
print(transfer_mutation_result)


balance_query = """
query { 
  balance(address:"0xEb3907eCad74a0013c259D5874AE7f22DcBcC95C", tokenSymbols:["GFT"]){
    balanceNetwork
    balanceIncoming
    balanceOutgoing
    balanceAvailable
  }
}

"""
# balance_query_result = schema.execute(balance_query)
# print(balance_query_result)


transactions_query = """
query { 
  transactions(address:"0xEb3907eCad74a0013c259D5874AE7f22DcBcC95C")
}

"""
# transactions_query_result = schema.execute(transactions_query)
# print(transactions_query_result)