from flask import current_app, request
from flask_restful import Resource, abort
from flask_restful.reqparse import RequestParser
from werkzeug.exceptions import BadRequest

from hasoffers.core.model import Session, Order
from hasoffers.core.util.helpers.google_services import recaptcha_confirm


def recaptcha_type(value):
    if not recaptcha_confirm(value, request.remote_addr):
        raise ValueError('invalid captcha')
    return value


class GDPRAbuseResource(Resource):
    get_parser = RequestParser()
    get_parser.add_argument('name', type=unicode)
    get_parser.add_argument('phone', type=unicode)
    get_parser.add_argument('email', type=unicode)
    # get_parser.add_argument('g-recaptcha-response', type=recaptcha_type, required=True)

    def get(self):
        try:
            query = self.get_query()
            user = query.with_entities(Order.id, Order.name, Order.email, Order.phone,Order.ts_spawn).first()
            if user:
                return {
                    "data": {
                        "name": user._name,
                        "phone": user._phone,
                        "email": user._email,
                        "date": user.ts_spawn,
                    }
                }
            else:
                raise BadRequest('User with such params does not exist.')
        except BadRequest as e:
            Session.rollback()
            raise abort(400, message=e.description)
        except Exception as e:
            current_app.structlogger.exception(e)
            Session.rollback()
            raise e

    def delete(self):
        query = self. get_query()
        query.update({Order.flags: Order.flags.op('|')(Order.Flags.deleted_by_user)},
                     synchronize_session=False)
        try:
            Session.commit()
        except Exception as e:
            err_msg = 'Error while trying to delete user from db'
            logger.exception(err_msg)
            Session.rollback()
            raise BadRequest(err_msg)

    def get_query(self):
        args = self.get_parser.parse_args()

        if not args.name or not (args.email or args.phone):
            raise BadRequest('One of required field is empty')
        query = Order.query.filter(Order.name == args.name)
        if args.phone:
            query = query.filter(Order.phone == args.phone)
        if args.email:
            query = query.filter(Order.email == args.email)
        return query