import sys
import time

import requests
from db.db import DictDB
from db.index import CouchIindex
from fastapi import APIRouter, Depends, Request
from fastapi.responses import JSONResponse
from fastapi_jwt_auth import AuthJWT

router = APIRouter()

for i in range(10):
    try:
        db = DictDB()
    except requests.exceptions.ConnectionError:
        print('Database not responding, will try again soon.' +
              f'Attempt {i + 1} of 10.')
    else:
        break
    time.sleep(10)
else:
    print('Database did not respond after 10 attempts, quitting.')
    sys.exit(-1)


def get_data(key=None, limit=25, skip=0, ip=None,
             port=None, asn=None, domain=None):
    if key:
        return db.get(key)

    selectors = dict()
    indexes = CouchIindex().dict()
    selectors['domain'] = domain

    if ip and 'ip' in indexes:
        selectors['ip'] = ip
    if port and 'port' in indexes:
        selectors['port'] = port
    if asn and 'asn' in indexes:
        selectors['asn'] = asn

    data = db.search(**selectors, limit=limit, skip=skip)

    return data


@router.get('/get')
async def get(key=None, limit=25, skip=0, ip=None, port=None,
              asn=None, Authorize: AuthJWT = Depends()):

    Authorize.jwt_required()

    data = []
    raw_jwt = Authorize.get_raw_jwt()

    if "read" not in raw_jwt:
        return JSONResponse(
            content={
                "status": "error",
                "message": "Could not find read claim in JWT token",
            },
            status_code=400,
        )
    else:
        domains = raw_jwt["read"]

    for domain in domains:
        data.extend(get_data(key, limit, skip, ip, port, asn, domain))

    return JSONResponse(content={"status": "success", "docs": data})


@router.get('/get/{key}')
async def get_key(key=None, Authorize: AuthJWT = Depends()):

    Authorize.jwt_required()

    raw_jwt = Authorize.get_raw_jwt()

    if "read" not in raw_jwt:
        return JSONResponse(
            content={
                "status": "error",
                "message": "Could not find read claim in JWT token",
            },
            status_code=400,
        )
    else:
        allowed_domains = raw_jwt["read"]

    data = get_data(key)

    if data["domain"] not in allowed_domains:
        return JSONResponse(
            content={
                "status": "error",
                "message": "User not authorized to view this object",
            },
            status_code=400,
        )

    return JSONResponse(content={"status": "success", "docs": data})


@router.post('/add')
async def add(data: Request, Authorize: AuthJWT = Depends()):

    Authorize.jwt_required()

    json_data = await data.json()

    key = db.add(json_data)

    return JSONResponse(content={"status": "success", "docs": key})


@router.delete('/delete/{key}')
async def delete(key, Authorize: AuthJWT = Depends()):

    Authorize.jwt_required()

    raw_jwt = Authorize.get_raw_jwt()

    if "write" not in raw_jwt:
        return JSONResponse(
            content={
                "status": "error",
                "message": "Could not find write claim in JWT token",
            },
            status_code=400,
        )
    else:
        allowed_domains = raw_jwt["write"]

    data = get_data(key)

    if data["domain"] not in allowed_domains:
        return JSONResponse(
            content={
                "status": "error",
                "message": "User not authorized to delete this object",
            },
            status_code=400,
        )

    if db.delete(key) is None:
        return JSONResponse(content={"status": "error",
                                     "message": "Document not found"},
                            status_code=400)

    return JSONResponse(content={"status": "success", "docs": data})