#!/bin/python
#
# Cryptonote tipbot - withdrawal commands
# Copyright 2014,2015 moneromooo
# DNS code largely copied from Electrum OpenAlias plugin, Copyright 2014-2015 The monero Project
#
# The Cryptonote tipbot is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 2, or (at your option)
# any later version.
#

import redis
import json
import string
import re
import dns.name
import dns.dnssec
import dns.resolver
import dns.message
import dns.query
import dns.rdatatype
import dns.rdtypes.ANY.TXT
import dns.rdtypes.ANY.NS
from tipbot.log import log_error, log_warn, log_info, log_log
import tipbot.coinspecs as coinspecs
import tipbot.config as config
from tipbot.user import User
from tipbot.link import Link
from tipbot.utils import *
from tipbot.redisdb import *
from tipbot.command_manager import *

withdraw_disabled = False

def DisableWithdraw(link,cmd):
  global withdraw_disabled
  if link:
    log_warn('DisableWithdraw: disabled by %s' % link.identity())
  else:
    log_warn('DisableWithdraw: disabled')
  withdraw_disabled = True

def EnableWithdraw(link,cmd):
  global withdraw_disabled
  log_info('EnableWithdraw: enabled by %s' % link.identity())
  withdraw_disabled = False

def CheckDisableWithdraw():
  if config.disable_withdraw_on_error:
    DisableWithdraw(None,None)

def ValidateDNSSEC(address):
  log_info('Validating DNSSEC for %s' % address)
  try:
    resolver = dns.resolver.get_default_resolver()
    ns = resolver.nameservers[0]
    parts = address.split('.')
    for i in xrange(len(parts),0,-1):
      subpart = '.'.join(parts[i-1:])
      query = dns.message.make_query(subpart,dns.rdatatype.NS)
      response = dns.query.udp(query,ns,1)
      if response.rcode() != dns.rcode.NOERROR:
        return False
      if len(response.authority) > 0:
        rrset = response.authority[0]
      else:
        rrset = response.answer[0]
      rr = rrset[0]
      if rr.rdtype == dns.rdatatype.SOA:
        continue
      query = dns.message.make_query(subpart,dns.rdatatype.DNSKEY,want_dnssec=True)
      response = dns.query.udp(query,ns,1)
      if response.rcode() != 0:
        return False
      answer = response.answer
      if len(answer) != 2:
        return False
      name = dns.name.from_text(subpart)
      dns.dnssec.validate(answer[0],answer[1],{name:answer[0]})
      return True
  except Exception,e:
    log_error('Failed to validate DNSSEC for %s: %s' % (address, str(e)))
    return False

def ResolveCore(address,ctype):
  log_info('Resolving %s address for %s' % (ctype,address))
  address=address.replace('@','.')
  if not '.' in address:
    return False,'invalid address'

  try:
    for attempt in range(3):
      resolver = dns.resolver.Resolver()
      resolver.timeout = 2
      resolver.lifetime = 2
      records = resolver.query(address,dns.rdatatype.TXT)
      for record in records:
        s = record.strings[0]
        if s.lower().startswith('oa1:%s' % ctype.lower()):
          a = re.sub('.*recipient_address[ \t]*=[ \t]*\"?([A-Za-z0-9]+)\"?.*','\\1',s)
          if IsValidAddress(a):
            log_info('Found %s address at %s: %s' % (ctype,address,a))
            return True, [a,ValidateDNSSEC(address)]
  except Exception,e:
    log_error('Error resolving %s: %s' % (address,str(e)))

  return False, 'not found'

def Withdraw(link,cmd):
  identity=link.identity()

  local_withdraw_fee = config.withdrawal_fee or coinspecs.min_withdrawal_fee
  local_min_withdraw_amount = config.min_withdraw_amount or local_withdraw_fee

  if local_min_withdraw_amount <= 0 or local_withdraw_fee <= 0 or local_min_withdraw_amount < local_withdraw_fee:
    log_error('Withdraw: Inconsistent withdrawal settings')
    link.send("An error has occured")
    return

  try:
    address=cmd[1]
  except Exception,e:
    link.send("Usage: withdraw address [amount] [paymentid]")
    return

  if '.' in address:
    ok,extra=ResolveCore(address,coinspecs.symbol)
    if not ok:
      link.send('Error: %s' % extra)
      return
    a=extra[0]
    dnssec=extra[1]
    if not dnsssec:
      link.send('%s address %s was found for %s' % (coinspecs.name,a,address))
      link.send('Trust chain could not be verified, so withdrawal was not automatically performed')
      link.send('Withdraw using this %s address if it is correct' % coinspecs.name)
      return
    address=a

  if not IsValidAddress(address):
    link.send("Invalid address")
    return

  if GetParam(cmd,3):
    amount = GetParam(cmd,2)
    paymentid = GetParam(cmd,3)
  else:
    if GetParam(cmd,2) and IsValidPaymentID(GetParam(cmd,2)):
      amount = None
      paymentid = GetParam(cmd,2)
    else:
      amount = GetParam(cmd,2)
      paymentid = None

  if amount:
    try:
      amount = StringToUnits(amount)
      if (amount <= 0):
        raise RuntimeError("")
      amount += local_withdraw_fee
    except Exception,e:
      link.send("Invalid amount")
      return
  if paymentid != None:
    if not IsValidPaymentID(paymentid):
      link.send("Invalid payment ID")
      return

  log_info("Withdraw: %s wants to withdraw %s to %s" % (identity, AmountToString(amount) if amount else "all", address))

  if withdraw_disabled:
    log_error('Withdraw: disabled')
    link.send("Sorry, withdrawal is disabled due to a wallet error which requires admin assistance")
    return

  account = GetAccount(identity)
  try:
    balance = redis_hget('balances',account)
    if balance == None:
      balance = 0
    balance=long(balance)
  except Exception, e:
    log_error('Withdraw: exception: %s' % str(e))
    link.send("An error has occured")
    return

  if amount:
    if amount > balance:
      log_info("Withdraw: %s trying to withdraw %s, but only has %s" % (identity,AmountToString(amount),AmountToString(balance)))
      link.send("You only have %s" % AmountToString(balance))
      return
  else:
    amount = balance

  if amount <= 0 or amount < local_min_withdraw_amount:
    log_info("Withdraw: Minimum withdrawal balance: %s, %s cannot withdraw %s" % (AmountToString(config.min_withdraw_amount),identity,AmountToString(amount)))
    link.send("Minimum withdrawal balance: %s, cannot withdraw %s" % (AmountToString(config.min_withdraw_amount),AmountToString(amount)))
    return
  try:
    fee = long(local_withdraw_fee)
    topay = long(amount - fee)
    log_info('Withdraw: Raw: fee: %s, to pay: %s' % (str(fee), str(topay)))
    log_info('Withdraw: fee: %s, to pay: %s' % (AmountToString(fee), AmountToString(topay)))
    params = {
      'destinations': [{'address': address, 'amount': topay}],
      'payment_id': paymentid,
      'fee': coinspecs.min_withdrawal_fee,
      'mixin': config.withdrawal_mixin,
      'unlock_time': 0,
    }
    j = SendWalletJSONRPCCommand("transfer",params)
  except Exception,e:
    log_error('Withdraw: Error in transfer: %s' % str(e))
    CheckDisableWithdraw()
    link.send("An error has occured")
    return
  if not "result" in j:
    log_error('Withdraw: No result in transfer reply')
    CheckDisableWithdraw()
    link.send("An error has occured")
    return
  result = j["result"]
  if not "tx_hash" in result:
    log_error('Withdraw: No tx_hash in transfer reply')
    CheckDisableWithdraw()
    link.send("An error has occured")
    return
  tx_hash = result["tx_hash"]
  log_info('%s has withdrawn %s, tx hash %s' % (identity, amount, str(tx_hash)))
  link.send( "Tx sent: %s" % tx_hash)

  try:
    redis_hincrby("balances",account,-amount)
  except Exception, e:
    log_error('Withdraw: FAILED TO SUBTRACT BALANCE: exception: %s' % str(e))
    CheckDisableWithdraw()

def Resolve(link,cmd):
  try:
    address=GetParam(cmd,1)
    if not address:
      raise RuntimeError("")
  except Exception,e:
    link.send('usage: !resolve <address>')
    return
  ok,extra=ResolveCore(address,coinspecs.symbol)
  if not ok:
    link.send('Error: %s' % extra)
    return
  a=extra[0]
  dnssec=extra[1]
  if dnssec:
    link.send('Found %s address at %s: %s' % (coinspecs.symbol,address,a))
  else:
    link.send('Found %s address at %s via insecure DNS: %s' % (coinspecs.symbol,address,a))

def Help(link):
  fee = config.withdrawal_fee or coinspecs.min_withdrawal_fee
  min_amount = config.min_withdraw_amount or fee
  link.send_private("Partial or full withdrawals can be made to any %s address" % coinspecs.name)
  link.send_private("OpenAlias is supported, to pay directly to a domain name which uses it")
  link.send_private("Minimum withdrawal: %s" % AmountToString(min_amount))
  link.send_private("Withdrawal fee: %s" % AmountToString(fee))



RegisterModule({
  'name': __name__,
  'help': Help,
})
RegisterCommand({
  'module': __name__,
  'name': 'withdraw',
  'parms': '<address>|<domain-name> [<amount>] [paymentid]',
  'function': Withdraw,
  'registered': True,
  'help': "withdraw part or all of your balance"
})
RegisterCommand({
  'module': __name__,
  'name': 'resolve',
  'parms': '<address>',
  'function': Resolve,
  'registered': True,
  'help': "Resolve a %s address from DNS with OpenAlias" % coinspecs.name
})
RegisterCommand({
  'module': __name__,
  'name': 'enable_withdraw',
  'function': EnableWithdraw,
  'admin': True,
  'help': "Enable withdrawals"
})
RegisterCommand({
  'module': __name__,
  'name': 'disable_withdraw',
  'function': DisableWithdraw,
  'admin': True,
  'help': "Disable withdrawals"
})