from web3.auto import w3
from eth_account.messages import encode_defunct
import requests
import json
import pprint
from eip712_structs import make_domain
from eip712_structs import Address, Boolean, Bytes, String, Uint
from eip712_structs import EIP712Struct
import time
from hexbytes import HexBytes


network = "xdai"

if(network == "mainnet"):
    base_url = "https://protocol-mainnet.gnosis.io/api/v1/"
    private_key = "YOUR_PRIVATE_KEY_YOU_CAN_E.G._EXPORT_FROM_METAMASK"
    public_address = "YOUR_ADDRESS"
    domain = make_domain(name='Gnosis Protocol', version='v2', chainId='1', verifyingContract="0x9008D19f58AAbD9eD0D60971565AA8510560ab41")  # Make a Domain Separator
else:
    base_url = "https://protocol-xdai.gnosis.io/api/v1/"
    private_key = "YOUR_PRIVATE_KEY_YOU_CAN_E"
    public_address = "YOUR_ADDRESS"
    domain = make_domain(name='Gnosis Protocol', version='v2', chainId='100', verifyingContract="0x9008D19f58AAbD9eD0D60971565AA8510560ab41")  # Make a Domain Separator



class Order(EIP712Struct):
    sellToken = Address()
    buyToken = Address()
    receiver = Address()
    sellAmount = Uint(256)
    buyAmount = Uint(256)
    validTo = Uint(32)
    appData = Bytes(32)
    feeAmount = Uint(256)
    kind = String()
    partiallyFillable = Boolean()
    sellTokenBalance = String()
    buyTokenBalance = String()


def placeOrder(myorder):


    my_bytes = myorder.signable_bytes(domain)
    hash = w3.keccak(my_bytes)
    message = encode_defunct(primitive=hash)


    signed_message = w3.eth.account.sign_message(message, private_key=private_key)
    #print(signed_message)


    json_str = '''{
      "sellToken": "''' + str(myorder["sellToken"]) + '''",
      "buyToken": "''' + str(myorder["buyToken"]) + '''",
      "receiver": "''' + str(myorder["receiver"]) + '''",
      "sellAmount": "''' + str(myorder["sellAmount"]) + '''",
      "buyAmount": "''' + str(myorder["buyAmount"]) + '''",
      "validTo": ''' + str(myorder["validTo"]) + ''',
      "appData": "''' + str(myorder["appData"].hex()) + '''",
      "feeAmount": "''' + str(myorder["feeAmount"]) + '''",
      "kind": "''' + str(myorder["kind"]) + '''",
      "partiallyFillable": ''' + str(myorder["partiallyFillable"]).lower() + ''',
      "signature": "''' + str(signed_message.signature.hex()) + '''",
      "signingScheme": "ethsign",
      "sellTokenBalance": "''' + str(myorder["sellTokenBalance"]) +'''",
      "buyTokenBalance": "''' + str(myorder["buyTokenBalance"]) +'''",
      "from": "''' + public_address + '''"
    }'''

    print(json_str)
    '''json_dict = {}
    json_dict["sellToken"] = sellToken
    json_dict["buyToken"] = buyToken
    json_dict["receiver"] = receiver
    json_dict["sellAmount"] = str(sellAmount)
    json_dict["buyAmount"] = str(buyAmount)
    json_dict["validTo"] = validTo
    json_dict["appData"] = appData
    json_dict["feeAmount"] = str(feeAmount)
    json_dict["kind"] = kind
    json_dict["partiallyFillable"] = str(partiallyFillable).lower()
    json_dict["signature"] = str(signed_message.signature.hex())
    json_dict["signingScheme"] = "ethsign"
    json_dict["sellTokenBalance"] = str(sellTokenBalance)
    json_dict["buyTokenBalance"] = str(buyTokenBalance)
    json_dict["from"] = public_address'''

    #print(json_str)
    j = json.loads(json_str)

    #pprint.pprint(j)

    r = requests.post(base_url + "orders", json=j)

    print("Status code: ", r.status_code)
    print(r.json())

query = "solvable_orders"
first_response = requests.get(base_url+query)
response_list=first_response.json()


pprint.pprint(response_list)


def createCounterOrder(order):
    return_order = Order()
    return_order["sellToken"] = order["buyToken"]
    if(return_order["sellToken"]=="0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"):
        #TODO use WETH address for mainnet
        return_order["sellToken"] = "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
    return_order["buyToken"] = order["sellToken"]
    if(return_order["buyToken"]=="0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"):
        return_order["buyToken"] = "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
    return_order["receiver"] = public_address
    return_order["sellAmount"] = int(int(order["buyAmount"]) * 1.0025)
    return_order["buyAmount"] = int(int(order["sellAmount"]) * 0.9985)
    return_order["validTo"] = int(time.time()) + 120
    return_order["appData"] = HexBytes("0x0000000000000000000000000000000000000000000000000000000000000ccc")
    if (order["kind"] == "sell"):
        return_order["kind"] = "buy"
    else:
        return_order["kind"] = "sell"

    return_order["feeAmount"] = int(getFee(return_order))
    return_order["partiallyFillable"] = False
    return_order["sellTokenBalance"] = "erc20"
    return_order["buyTokenBalance"] = "erc20"
    return(return_order)


def getFee(order):
    if (order["kind"] == "sell"):
        fee = requests.get(base_url +  "fee?sellToken=" + order["sellToken"] +  "&buyToken=" + order["buyToken"] + "&amount=" + str(order["sellAmount"]) + "&kind=" + order["kind"])
    elif (order["kind"] == "buy"):
        fee = requests.get(base_url +  "fee?sellToken=" + order["sellToken"] +  "&buyToken=" + order["buyToken"] + "&amount=" + str(order["buyAmount"]) + "&kind=" + order["kind"])
    else:
        print("Unknown order type")
        return
    print(fee.json())
    return fee.json()["amount"]

stablecoins = {}
#USDC
stablecoins["0xddafbb505ad214d7b80b1f830fccc89b60fb7a83"] = 6
#wxDAI
stablecoins["0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"] = 18
#USDT
stablecoins["0x4ecaba5870353805a9f068101a40e0f32ed605c6"] = 6

for i in range((len(response_list))):
    counter_order = createCounterOrder(response_list[i])
    if(counter_order["sellToken"] in stablecoins.keys()) and \
        counter_order["buyToken"] in stablecoins.keys() and \
        counter_order["buyAmount"] / 10** stablecoins[counter_order["buyToken"]] > counter_order["sellAmount"] / 10** stablecoins[counter_order["sellToken"]]:

        print("hurray")
        print(counter_order["buyAmount"] / 10** stablecoins[counter_order["buyToken"]])
        print(counter_order["sellAmount"] / 10** stablecoins[counter_order["sellToken"]])
        placeOrder(counter_order)