def error(request):
    log.info('Bango error: %s' % request.GET)

    # We should NOT have OK's coming from Bango, presumably.
    if request.GET.get('ResponseCode') == 'OK':
        log.error('in error(): Invalid Bango response code: {code}'
                  .format(code=request.GET.get('ResponseCode')))
        return system_error(request, code=msg.BAD_BANGO_CODE)

    result = _record(request)
    if result is not RECORDED_OK:
        return system_error(request, code=result)

    if request.GET.get('ResponseCode') == 'CANCEL':
        return render(request, 'bango/cancel.html',
                      {'error_code': msg.USER_CANCELLED})

    if request.GET.get('ResponseCode') == 'NOT_SUPPORTED':
        # This is a credit card or price point / region mismatch.
        # In theory users should never trigger this.
        return system_error(request, code=msg.UNSUPPORTED_PAY)

    log.error('Fatal Bango error: {code}; query string: {qs}'
              .format(code=request.GET.get('ResponseCode'),
                      qs=request.GET))
    return system_error(request, code=msg.BANGO_ERROR)

def success(request):
    """
    Process a redirect request after the Bango payment has completed.
    This URL endpoint is pre-arranged with Bango via the Billing Config API.

    Example request:

    ?ResponseCode=OK&ResponseMessage=Success&BangoUserId=1473894939
    &MerchantTransactionId=webpay%3a14d6a53c-fc4c-4bd1-8dc0-9f24646064b8
    &BangoTransactionId=1078692145
    &TransactionMethods=USA_TMOBILE%2cT-Mobile+USA%2cTESTPAY%2cTest+Pay
    &BillingConfigurationId=218240
    &MozSignature=
    c2cf7b937720c6e41f8b6401696cf7aef56975ebe54f8cee51eff4eb317841af
    &Currency=USD&Network=USA_TMOBILE&Price=0.99&P=
    """
    log.info('Bango success: %s' % request.GET)

    # We should only have OK's coming from Bango, presumably.
    if request.GET.get('ResponseCode') != 'OK':
        log.error('in success(): Invalid Bango response code: {code}'
                  .format(code=request.GET.get('ResponseCode')))
        return system_error(request, code=msg.BAD_BANGO_CODE)

    result = _record(request)
    if result is not RECORDED_OK:
        return system_error(request, code=result)

    # Signature verification was successful; fulfill the payment.
    tasks.payment_notify.delay(request.GET.get('MerchantTransactionId'))
    return render(request, 'bango/success.html')

def configure_transaction(request, data=None):
    """
    Configures a transaction so the user can be redirected to a buy screen.

    This is called from the client so that it can provide
    MCC/MNC at the same time.

    * When configure_transaction fails this will return a 400
      TRANS_CONFIG_FAILED

    """

    form = NetCodeForm(data or request.POST)

    mcc = None
    mnc = None
    if form.is_valid():
        mcc = form.cleaned_data['mcc']
        mnc = form.cleaned_data['mnc']
        log.info('Client detected network: mcc={mcc}, mnc={mnc}'
                 .format(mcc=mcc, mnc=mnc))
    else:
        log.info('Network form was invalid, no codes were applied.')
        log.debug('Network form errors: {e}'.format(e=form.errors.as_text()))

    if settings.SIMULATED_NETWORK:
        mcc = settings.SIMULATED_NETWORK['mcc']
        mnc = settings.SIMULATED_NETWORK['mnc']
        log.warning('OVERRIDING detected network with: mcc={mcc}, mnc={mnc}'
                    .format(mcc=mcc, mnc=mnc))

    is_simulation = request.session.get('is_simulation', False)
    pay_req = request.session.get('notes', {}).get('pay_request')
    payment_required = (
        pay_req['request']['pricePoint'] != '0' if pay_req else True)

    if payment_required:
        was_configured, error_code = tasks.configure_transaction(
            request, mcc=mcc, mnc=mnc)
        if not was_configured and not is_simulation:
            if not error_code:
                error_code = msg.TRANS_CONFIG_FAILED
            log.error('Configuring transaction failed: {er}'
                      .format(er=error_code))
            return system_error(request, code=error_code)
    else:
        solitude_buyer_uuid = request.session['uuid']
        log.info('Notifying for free in-app trans_id={t}; with '
                 'solitude_buyer_uuid={u}'.format(
                     t=request.session['trans_id'], u=solitude_buyer_uuid))
        tasks.free_notify.delay(request.session['notes'], solitude_buyer_uuid)

    sim = pay_req['request']['simulate'] if is_simulation else None
    client_trans_id = 'client-trans:{u}'.format(u=uuid.uuid4())
    log.info('Assigned client trans ID {client_trans} to trans ID {trans}'
             .format(trans=request.session['trans_id'],
                     client_trans=client_trans_id))
    return {'status': 'ok', 'simulation': sim,
            'client_trans_id': client_trans_id,
            'payment_required': payment_required}

def super_simulate(request):
    if not settings.ALLOW_ADMIN_SIMULATIONS:
        return http.HttpResponseForbidden()

    form = SuperSimulateForm(request.POST or None)
    if request.method == 'POST' and form.is_valid():

        if form.cleaned_data['action'] == 'real':
            if form.cleaned_data['network']:
                mcc, mnc = form.cleaned_data['network']
                was_configured, error_code = reconfigure_transaction(
                    request, mcc, mnc)
                if not was_configured:
                    if not error_code:
                        error_code = msg.TRANS_CONFIG_FAILED
                    log.error('Re-configuring transaction failed: {er}'
                              .format(er=error_code))
                    return system_error(request, code=error_code)

            # Continue to the wait screen.
            return redirect(reverse('pay.wait_to_start'))

        elif form.cleaned_data['action'] == 'simulate':
            send_simulated_notification(request.session['trans_id'])
            return render(request, 'pay/simulate_done.html', {})

        else:
            raise ValueError('Not sure what to do for action {a}'
                             .format(a=form.cleaned_data['action']))

    return render(request, 'pay/super_simulate.html', {'form': form})

def configure_transaction(request):
    """Configures the transaction to save time later.

    This is called from the client so that it can provide
    MCC/MNC at the same time.

    * When configure_transaction fails this will return a 400
      TRANS_CONFIG_FAILED

    """

    form = NetCodeForm(request.POST)
    sess = request.session

    if form.is_valid():
        mcc = form.cleaned_data['mcc']
        mnc = form.cleaned_data['mnc']
        notes = sess.get('notes', {})
        notes['network'] = {'mnc': mnc, 'mcc': mcc}
        sess['notes'] = notes
        log.info('Added mcc/mnc to session: '
                 '{network}'.format(network=notes['network']))

    log.info('configuring transaction {0} from client'
             .format(sess.get('trans_id')))

    if not tasks.configure_transaction(request):
        log.error('Configuring transaction failed.')
        return system_error(request, code=msg.TRANS_CONFIG_FAILED)
    else:
        return {'status': 'ok'}

def lobby(request):
    sess = request.session
    trans = None
    have_jwt = bool(request.GET.get('req'))

    log.info('starting from JWT? {have_jwt}'.format(have_jwt=have_jwt))
    if have_jwt:
        # If it returns a response there was likely
        # an error and we should return it.
        res = process_pay_req(request)
        if isinstance(res, http.HttpResponse):
            return res
    elif settings.TEST_PIN_UI:
        # This won't get you very far but it lets you create/enter PINs
        # and stops a traceback after that.
        sess['trans_id'] = trans_id()
    elif not sess.get('is_simulation', False):
        try:
            trans = solitude.get_transaction(sess.get('trans_id'))
        except (ObjectDoesNotExist, HttpClientError), exc:
            if sess.get('trans_id'):
                log.info('Attempted to restart non-existent transaction '
                         '{trans}; exc={exc}'
                         .format(trans=sess.get('trans_id'), exc=exc))
            return system_error(request, code=msg.BAD_REQUEST)

        log.info('Re-used existing transaction ID: {tx}'
                 .format(tx=sess.get('trans_id')))

def was_locked(request):
    try:
        client.unset_was_locked(uuid=get_user(request))
    except ResourceModified:
        return system_error(request, code=msg.RESOURCE_MODIFIED)
    request.session['uuid_pin_was_locked'] = False
    return render(request, 'pin/pin_was_locked.html')

def reset_cancel(request):
    try:
        client.set_needs_pin_reset(get_user(request), False)
    except ResourceModified:
        return system_error(request, code=msg.RESOURCE_MODIFIED)
    request.session['uuid_needs_pin_reset'] = False
    return http.HttpResponseRedirect(reverse('pin.verify'))

def create(request):
    form = forms.CreatePinForm()
    if request.method == 'POST':
        form = forms.CreatePinForm(uuid=get_user(request), data=request.POST)
        if form.is_valid():
            if getattr(form, 'buyer_exists', False):
                try:
                    res = client.change_pin(form.uuid,
                                            form.cleaned_data['pin'],
                                            etag=form.buyer_etag)
                except ResourceModified:
                    return system_error(request, code=msg.RESOURCE_MODIFIED)
            else:
                res = client.create_buyer(form.uuid, form.cleaned_data['pin'])
            if form.handle_client_errors(res):
                set_user_has_pin(request, True)
                return http.HttpResponseRedirect(reverse('pin.confirm'))
    form.no_pin = True
    return render(request, 'pin/pin_form.html', {'form': form,
                  'title': _('Create a Pin'),
                  'action': reverse('pin.create'),
                  'pin_form_tracking' : {
                      'pin_error_codes': form.pin_error_codes,
                  },
                  'track_cancel': {
                      'action': 'pin cancel',
                      'label': 'Create Pin Page',
                  }})

def configure_transaction(request):
    """
    Configures a transaction so the user can be redirected to a buy screen.

    This is called from the client so that it can provide
    MCC/MNC at the same time.

    * When configure_transaction fails this will return a 400
      TRANS_CONFIG_FAILED

    """

    form = NetCodeForm(request.POST)

    mcc = None
    mnc = None
    if form.is_valid():
        mcc = form.cleaned_data['mcc']
        mnc = form.cleaned_data['mnc']
        log.info('Client detected network: mcc={mcc}, mnc={mnc}'
                 .format(mcc=mcc, mnc=mnc))

    if settings.SIMULATED_NETWORK:
        mcc = settings.SIMULATED_NETWORK['mcc']
        mnc = settings.SIMULATED_NETWORK['mnc']
        log.warning('OVERRIDING detected network with: mcc={mcc}, mnc={mnc}'
                    .format(mcc=mcc, mnc=mnc))

    if not tasks.configure_transaction(request, mcc=mcc, mnc=mnc):
        log.error('Configuring transaction failed.')
        return system_error(request, code=msg.TRANS_CONFIG_FAILED)
    else:
        return {'status': 'ok'}

def error(request, provider):
    if provider != 'reference':
        raise NotImplementedError(
                'only the reference provider is implemented so far')

    notice = NoticeClasses[provider](request)
    try:
        notice.prepare()
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    # TODO: handle user cancellation, bug 957774.

    log.error('Fatal payment error for {provider}: {code}; query string: {qs}'
              .format(provider=provider, code=request.GET.get('ResponseCode'),
                      qs=request.GET))
    return system_error(request, code=msg.EXT_ERROR)

def lobby(request):
    sess = request.session
    have_jwt = bool(request.GET.get('req'))

    log.info('starting from JWT? {have_jwt}'.format(have_jwt=have_jwt))
    if have_jwt:
        # If it returns a response there was likely
        # an error and we should return it.
        res = process_pay_req(request)
        if isinstance(res, http.HttpResponse):
            return res
    elif settings.TEST_PIN_UI:
        # This won't get you very far but it lets you create/enter PINs
        # and stops a traceback after that.
        sess['trans_id'] = trans_id()

    pin_form = VerifyPinForm()

    if sess.get('uuid'):
        auth_utils.update_session(request,
                                  sess.get('uuid'),
                                  False,
                                  request.session.get('logged_in_user', None))

        redirect_url = check_pin_status(request)
        if redirect_url is not None:
            return http.HttpResponseRedirect(
                '{0}?next={1}'.format(reverse('pay.bounce'), redirect_url)
            )

    # If the buyer closed the trusted UI during reset flow, we want to unset
    # the reset pin flag. They can hit the forgot pin button if they still
    # don't remember their pin.
    if sess.get('uuid_needs_pin_reset'):
        try:
            solitude.set_needs_pin_reset(sess['uuid'], False)
        except ResourceModified:
            return system_error(request, code=msg.RESOURCE_MODIFIED)
        sess['uuid_needs_pin_reset'] = False

    if sess.get('is_simulation', False):
        sim_req = sess['notes']['pay_request']['request']['simulate']
        log.info('Starting simulate %s for %s'
                 % (sim_req, sess['notes']['issuer_key']))
        return render(request, 'pay/simulate.html', {
            'simulate': sim_req
        })

    return render(request, 'pay/lobby.html', {
        'action': reverse('pin.verify'),
        'form': pin_form,
        'title': _('Enter Pin'),
        'track_cancel': {
            'action': 'pin cancel',
            'label': 'Pin Entry Page',
        },
    })

def error(request, provider_name):
    provider = ProviderHelper(provider_name)
    if provider.name != 'reference':
        raise NotImplementedError(
            'only the reference provider is implemented so far')

    try:
        provider.prepare_notice(request)
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    # TODO: handle user cancellation, bug 957774.

    log.error('Fatal payment error for {provider}: {code}; query string: {qs}'
              .format(provider=provider.name,
                      code=request.GET.get('ResponseCode'),
                      qs=request.GET))
    return system_error(request, code=msg.EXT_ERROR)

def success(request, provider):
    if provider != 'reference':
        raise NotImplementedError(
                'only the reference provider is implemented so far')

    notice = NoticeClasses[provider](request)
    try:
        notice.prepare()
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    tasks.payment_notify.delay(notice.transaction_id)
    return render(request, 'provider/success.html')

def success(request, provider_name):
    provider = ProviderHelper(provider_name)
    if provider.name != 'reference':
        raise NotImplementedError(
            'only the reference provider is implemented so far')

    try:
        transaction_id = provider.prepare_notice(request)
    except msg.DevMessage as m:
        return system_error(request, code=m.code)

    tasks.payment_notify.delay(transaction_id)
    return render(request, 'provider/success.html')

def lobby(request):
    sess = request.session
    have_jwt = bool(request.GET.get("req"))

    log.info("starting from JWT? {have_jwt}".format(have_jwt=have_jwt))
    if have_jwt:
        # If it returns a response there was likely
        # an error and we should return it.
        res = process_pay_req(request)
        if isinstance(res, http.HttpResponse):
            return res
    elif settings.TEST_PIN_UI:
        # This won't get you very far but it lets you create/enter PINs
        # and stops a traceback after that.
        sess["trans_id"] = trans_id()

    pin_form = VerifyPinForm()

    if sess.get("uuid"):
        auth_utils.update_session(request, sess.get("uuid"), False)

        redirect_url = check_pin_status(request)
        if redirect_url is not None:
            return http.HttpResponseRedirect("{0}?next={1}".format(reverse("pay.bounce"), redirect_url))

    # If the buyer closed the trusted UI during reset flow, we want to unset
    # the reset pin flag. They can hit the forgot pin button if they still
    # don't remember their pin.
    if sess.get("uuid_needs_pin_reset"):
        try:
            solitude.set_needs_pin_reset(sess["uuid"], False)
        except ResourceModified:
            return system_error(request, code=msg.RESOURCE_MODIFIED)
        sess["uuid_needs_pin_reset"] = False

    if sess.get("is_simulation", False):
        sim_req = sess["notes"]["pay_request"]["request"]["simulate"]
        log.info("Starting simulate %s for %s" % (sim_req, sess["notes"]["issuer_key"]))
        return render(request, "pay/simulate.html", {"simulate": sim_req})

    return render(
        request,
        "pay/lobby.html",
        {
            "action": reverse("pin.verify"),
            "form": pin_form,
            "title": _("Enter Pin"),
            "track_cancel": {"action": "pin cancel", "label": "Pin Entry Page"},
        },
    )

def error(request):
    log.info("Bango error: %s" % request.GET)

    # We should NOT have OK's coming from Bango, presumably.
    if request.GET.get("ResponseCode") == "OK":
        log.error("in error(): Invalid Bango response code: {code}".format(code=request.GET.get("ResponseCode")))
        return system_error(request, code=msg.BAD_BANGO_CODE)

    result = _record(request)
    if result is not RECORDED_OK:
        return system_error(request, code=result)

    if request.GET.get("ResponseCode") == "CANCEL":
        return system_error(request, code=msg.USER_CANCELLED)

    if request.GET.get("ResponseCode") == "NOT_SUPPORTED":
        # This is a credit card or price point / region mismatch.
        # In theory users should never trigger this.
        return system_error(request, code=msg.UNSUPPORTED_PAY)

    log.error(
        "Fatal Bango error: {code}; query string: {qs}".format(code=request.GET.get("ResponseCode"), qs=request.GET)
    )
    return system_error(request, code=msg.BANGO_ERROR)

def reset_start(request):
    request.session['was_reverified'] = False
    try:
        client.set_needs_pin_reset(get_user(request))
    except ResourceModified:
        return system_error(request, code=msg.RESOURCE_MODIFIED)
    request.session['uuid_needs_pin_reset'] = True
    form = forms.CreatePinForm()
    form.reset_flow = True
    return render(request, 'pin/reset_start.html',
                  {'title': _('Reset Pin'),
                   'action': reverse('pin.reset_new_pin'),
                   'form': form,
                   'track_cancel': {
                       'action': 'pin cancel',
                       'label': 'Reset Start Page',
                   }})

def configure_transaction(request):
    """Configures the transaction to save time later.

    This is called from the client so that it can provide
    MCC/MNC at the same time.

    * When configure_transaction fails this will return a 400
      TRANS_CONFIG_FAILED

    """

    form = NetCodeForm(request.POST)
    sess = request.session

    mcc = None
    mnc = None
    if form.is_valid():
        mcc = form.cleaned_data['mcc']
        mnc = form.cleaned_data['mnc']
        log.info('Client detected network: mcc={mcc}, mnc={mnc}'
                 .format(mcc=mcc, mnc=mnc))

    if settings.SIMULATED_NETWORK:
        mcc = settings.SIMULATED_NETWORK['mcc']
        mnc = settings.SIMULATED_NETWORK['mnc']
        log.warning('OVERRIDING detected network with: mcc={mcc}, mnc={mnc}'
                    .format(mcc=mcc, mnc=mnc))

    notes = sess.get('notes', {})
    if mcc and mnc:
        notes['network'] = {'mnc': mnc, 'mcc': mcc}
    else:
        # Reset network state to avoid leakage from previous states.
        notes['network'] = {}
    sess['notes'] = notes
    log.info('Added mcc/mnc to session: '
             '{network}'.format(network=notes['network']))

    log.info('configuring transaction {0} from client'
             .format(sess.get('trans_id')))

    if not tasks.configure_transaction(request):
        log.error('Configuring transaction failed.')
        return system_error(request, code=msg.TRANS_CONFIG_FAILED)
    else:
        return {'status': 'ok'}

def wait_to_start(request):
    """
    Wait until the transaction is in a ready state.

    The transaction was started previously during the buy flow in the
    background from webpay.pay.tasks.

    Serve JS that polls for transaction state.
    When ready, redirect to the Bango payment URL using
    the generated billing configuration ID.
    """
    trans_id = request.session.get('trans_id', None)
    if not trans_id:
        # This seems like a seriously problem but maybe there is just a race
        # condition. If we see a lot of these in the logs it means the
        # payment will never complete so we should keep an eye on it.
        log.error('wait_to_start() session trans_id {t} was None'
                  .format(t=trans_id))
    try:
        statsd.incr('purchase.payment_time.retry')
        with statsd.timer('purchase.payment_time.get_transation'):
            trans = solitude.get_transaction(trans_id)
    except ObjectDoesNotExist:
        trans = {'status': None}

    if trans['status'] in constants.STATUS_ENDED:
        statsd.incr('purchase.payment_time.failure')
        log.exception('Attempt to restart finished transaction {0} '
                      'with status {1}'.format(trans_id, trans['status']))
        return system_error(request, code=msg.TRANS_ENDED)

    if trans['status'] == constants.STATUS_PENDING:
        statsd.incr('purchase.payment_time.success')
        payment_start = request.session.get('payment_start', False)
        if payment_start:
            delta = int((time.time() - float(payment_start)) * 1000)
            statsd.timing('purchase.payment_time.duration', delta)
        # Dump any messages so we don't show them later.
        clear_messages(request)
        # The transaction is ready; no need to wait for it.
        url = get_payment_url(trans)
        log.info('immediately redirecting to payment URL {url} '
                 'for trans {tr}'.format(url=url, tr=trans))
        return http.HttpResponseRedirect(url)
    return render(request, 'pay/wait-to-start.html')