############
# Defined in modules/monero.py
# two undefined func/var are os.environ related
XMR_RPC_PORT = '38088' if is_dev() and STAGENET_IN_DEV else '18088'
# TODO: v1.5 use ipv6
XMR_RPC_ENDPOINT = f'http://127.0.0.1:{XMR_RPC_PORT}/json_rpc'

def xmr_rpc_api(method_name, **params):
    rpc_defaults = {'jsonrpc': '2.0', 'id': '0'}
    if '_in' in params:
        params['in'] = params.pop('_in')
    return requests.post(XMR_RPC_ENDPOINT, json={**rpc_defaults, 'method': method_name, 'params': params}, auth=XMR_RPC_AUTH)
########

# called in the payment_method == monero order creation method
def finish_order_monero(order):
    """ Updates base order for paying with Monero """
    assert order['payment_method'] == 'monero'
    # Monero orders expire after one hour
    server_num = int(os.environ['SERVER_NUM'])
    try:
        # https://monerodocs.org/interacting/monero-wallet-rpc-reference/#create_address
        # create a new address for account idx server_num
        # PITFALL: it is imperative that the wallet file is not replaced, to avoid create_address returning an already used address
        # if the wallet is ever replaced, before starting the server, either change the account number or create addresses until it matches the address used by the last monero order
        r = xmr_rpc_api('create_address', account_index=server_num, label='lenerva-store-payment').json()
        while r.get('error'):
            if r['error']['code'] == -14:  # account index is out of bound (not created yet)
                account_created = False
                while not account_created:
                    r = xmr_rpc_api('create_account', label='lenerva-store').json()
                    account_created = r['result']['account_index'] == server_num
                r = xmr_rpc_api('create_address', account_index=server_num, label='lenerva-store-payment').json()
        address, address_idx = r['result']['address'], r['result']['address_index']
        total_xmr = usd_to_xmr(order['total_usd'])
        order.update({'xmr_address': address, 'xmr_address_idx': address_idx,
                      'total_xmr': total_xmr, 'total_xmr_atomic': total_xmr * 1e12})
    except Exception as e:
        raise MoneroError(repr(e)) from e

# showing order page to user
xmr_qr_data = f"monero:{order['xmr_address']}?tx_amount={order['total_xmr']}" \
              f"&tx_description=Goods%20and%20Services&recipient_name=LENERVA"

def monitor_xmr_payments(run_file: str):
    """
    Monitor Monero Payments Here
    Started from on_starting: multiprocessing
    One Monero Node per Server (Droplet)
    Unique Account per Server (Droplet)
    `run_file` implies that the main process is still running
    """
    # one hour order expiration
    XMR_ORDER_TIMEOUT = int(os.environ.get('XMR_ORDER_TIMEOUT', '3600'))
    XMR_EXTRA_TIME = int(os.environ.get('XMR_EXTRA_TIME', '3600'))
    ACCOUNT_IDX = int(os.environ['SERVER_NUM'])
    print('XMR Monitoring service started')
    update_check_time = 0
    while os.path.exists(run_file):
        time_start = time.monotonic()
        orders_to_check = Db.orders.find({'payment_method': 'monero', 'payment_confirmed': False,
                                          'expired': False, 'server_num': ACCOUNT_IDX})
        subaddr_indices = []
        expired_orders = []  # ids
        address_idx_orders = {}  # payment_addr_idx: order_doc
        for order in orders_to_check:
            addr_idx = order['xmr_address_idx']
            address_idx_orders[addr_idx] = order
            subaddr_indices.append(addr_idx)
            if order['timestamp'] + XMR_ORDER_TIMEOUT < time.time() and order['xmr_received'] == 0:
                # don't want to expire orders where payments have already started
                expired_orders.append(order['_id'])
            elif order['timestamp'] + XMR_ORDER_TIMEOUT + XMR_EXTRA_TIME < time.time():
                # expire orders that took too long to complete
                expired_orders.append(order['_id'])
        if expired_orders:
            Db.orders.update_one({'_id': {'$in': expired_orders}}, {'$set': {'expired': True}})
        balances = {}  # xmr_address_idx: {total_xmr_received ($set), total_confirmed_xmr ($set)}
        # check for payments (transfers)
        try:
            # https://monerodocs.org/interacting/monero-wallet-rpc-reference/#get_transfers
            if not subaddr_indices:
                raise StopIteration('No addresses to monitor')
            r = xmr_rpc_api('get_transfers', _in=True, out=False, pending=True, pool=True,
                            account_index=ACCOUNT_IDX, subaddr_indices=subaddr_indices).json()
            for transfer in chain(r['result'].get('in', []), r['result'].get('pending', [])):
                addr_idx = transfer['subaddr_index']['minor']
                if addr_idx not in address_idx_orders:
                    continue
                order = address_idx_orders[addr_idx]
                if addr_idx not in balances:
                    balances[addr_idx] = {'xmr_received': 0, 'xmr_confirmed': 0}
                balance = balances[addr_idx]
                # check timestamp just in case, double_spend_seen just in case,
                if (transfer['timestamp'] > order['timestamp'] and not transfer['double_spend_seen']
                        and addr_idx in address_idx_orders):
                    balance['xmr_received'] += transfer['amount']
                    if transfer['confirmations'] >= transfer['suggested_confirmations_threshold'] and transfer['confirmations'] > transfer.get('unlock_time', 0):
                        balance['xmr_confirmed'] += transfer['amount']
                        # check if confirmation resulted in order payment being fulfilled
                        # no need for buffer since fees are taken in addition to amount being sent
                        if balance['xmr_confirmed'] >= order['total_xmr_atomic']:
                            # payment confirmed, therefore, we can update the database
                            Db.orders.find_one_and_update({'_id': order['_id']}, {'$set': {
                                'xmr_received': round(balance['xmr_received'] / 1e12, 12),
                                'xmr_confirmed': round(balance['xmr_confirmed'] / 1e12, 12),
                                'payment_confirmed': True
                            }})
                            # del addr_idx from balances since we don't need to update this order again
                            del address_idx_orders[addr_idx]
                            del balances[addr_idx]
                            # quick exit for fast restarts
                            if not os.path.exists(run_file):
                                return
            for addr_idx in balances:
                # convert from atomic
                xmr_received = round(balances[addr_idx]['xmr_received'] / 1e12, 12)
                xmr_confirmed = round(balances[addr_idx]['xmr_confirmed'] / 1e12, 12)
                order = address_idx_orders[addr_idx]
                if xmr_received > order['xmr_received'] or xmr_confirmed > order['xmr_confirmed']:
                    # update xmr_* values for order
                    enough_xmr_sent = xmr_received >= order['total_xmr_atomic']
                    Db.orders.update_one({'_id': order['_id']}, {'$set': {
                        'xmr_received': xmr_received,
                        'xmr_confirmed': xmr_confirmed,
                        'enough_xmr_sent': enough_xmr_sent,
                    }})
        except StopIteration:
            pass
        except requests.RequestException:
            print('XMR RPC Connection Error - wallet is probably still syncing')
        # check for updates, and start update procedure
        if not is_dev() and update_check_time < time.time():
            # check for an update every 10 minutes
            update_monero_rpc()
            update_check_time = time.time() + 600
        # sleep to conserve resources
        if (time_taken := time.monotonic() - time_start) < INTERVAL:
            time.sleep(INTERVAL - time_taken)

add_to_path() {
  # if .env_path DNE or the parser has not been added to ~/.bashrc,
  if [ ! -f ~/.env_path ] && ! grep -Fq ".env_path" ~/.bashrc; then
    # shellcheck disable=SC2129
    echo "if [ -f ~/.env_path ]; then" >> ~/.bashrc
    # shellcheck disable=SC2140
    echo "    export PATH=\$PATH:\$(python3 -c "\""import os; from pathlib import Path; print(':'.join((line.strip() for line in open(f'{Path.home()}/.env_path').readlines() if line.strip())))"\"")" >> ~/.bashrc
    echo "fi" >> ~/.bashrc
  fi
  # add directories to path
  for path in "$@"; do
    if [ ! -f ~/.env_path ]  || ! grep -Fq "$path" ~/.env_path; then
      # .env_path DNE or string not in .env_path
      echo "$path" >> ~/.env_path
      echo "Added $path to PATH"
    fi
  done
  source ~/.bashrc
}

# shellcheck disable=SC2120,SC2164
install_monero() {
  # Install Monero (download and extract to ~/bin/monero)
  if [ ! -f ~/bin/monero/monerod ] || [ ! $1 = "--force" ]; then
    mkdir -p ~/Downloads && cd ~/Downloads
    echo "Downloading and extracting Monero binaries"
    curl -L https://downloads.getmonero.org/cli/linux64 | tar xj
    rm -r -f ~/bin/monero && mkdir -p ~/bin
    mv monero-*-linux-* monero
    mv monero ~/bin
    echo "Downloaded Monero binaries to" ~/bin
  else
    echo "INFO: Monero binaries already installed"
  fi
  add_to_path ~/bin/monero
  source ~/.bashrc
}

monero_rpc_cmd = [str(monero_rpc), '--config-file', 'other_files/monero-rpc.common.conf',
                      '--rpc-login', 'monero:' + os.environ['XMR_RPC_PW'],
                      '--trusted-daemon' if TRUSTED_DAEMON else '--untrusted-daemon',
                      '--rpc-bind-port', XMR_RPC_PORT, '--wallet-file', wallet_file, '--password']
# production only: (requires XMR_WALLET_PW set in .env or system environemnt variable)
monero_rpc_cmd.extend((os.environ['XMR_WALLET_PW'], '--daemon-address', MAINNET_DAEMON))