from configs.firebase import SERVER_TIMESTAMP, ArrayRemove, auth, db


def getUser(uid:str):
    ref = db.collection('users').document(uid).get()
    if ref.exists:
        return ref.to_dict()
    return None

def updateUserPassword(uid, password):
    try:
        user = auth.update_user(uid, password=password)
        return user
    except Exception as e:
        print(e)
    return None

def generateCustomToken(uid):
    try:
        token = auth.create_custom_token(uid)
        return token.decode()
    except Exception as e:
        print(e)
    return None

def checkUser(email):
    try:
        user = auth.get_user_by_email(email)
        userData = getUser(user.uid)
        return user, userData
    except Exception as e:
        print(e)
    return None, None


def checkUserByUid(uid):
    try:
        user = auth.get_user(uid)
        userData = getUser(user.uid)
        return user, userData
    except Exception as e:
        print(e)
    return None, None

def createUser(email, password, displayName, enterpriseId, isProUser=False, **kwargs):
    try:
        user = auth.create_user(
            email=email,
            password=password,
            display_name=displayName
        )
        if isProUser:
            db.collection("enterprises").document(user.uid).set(dict(
                id=user.uid,
                uid=user.uid,
                name=displayName,
                admins=[user.uid],
                isProUser=True,
                createdAt=SERVER_TIMESTAMP,
                hostnames = ["app.riverr.app"],
                email=email,
                **kwargs
            ), merge=True)
        db.collection('users').document(user.uid).set(dict(
                email = user.email,
                uid = user.uid,
                displayName = user.display_name,
                enterpriseId = enterpriseId if not isProUser else user.uid, 
                createdAt = SERVER_TIMESTAMP,
                updatedAt = SERVER_TIMESTAMP,
                isEnterpriseAdmin = isProUser,
                isProUser=isProUser,
                **kwargs
            ),
            merge=True
        )
        return user
    except Exception as e:
        print(e)
    return None


def createUserData(uid, email, displayName, enterpriseId, isProUser=False, **kwargs):
    try:
        if isProUser:
            db.collection("enterprises").document(uid).set(dict(
                id=uid,
                uid=uid,
                name=displayName,
                admins=[uid],
                isProUser=True,
                createdAt=SERVER_TIMESTAMP,
                hostnames = ["app.riverr.app"],
                email=email,
                **kwargs
            ), merge=True)
        db.collection('users').document(uid).set(dict(
                email = email,
                uid = uid,
                displayName = displayName,
                enterpriseId = enterpriseId if not isProUser else uid, 
                createdAt = SERVER_TIMESTAMP,
                updatedAt = SERVER_TIMESTAMP,
                isEnterpriseAdmin = isProUser,
                isProUser=isProUser,
                **kwargs
            ),
            merge=True
        )
        return uid
    except Exception as e:
        print(e)
    return None



def updateUserEnterprise(uid, enterpriseId):
    try:
        db.collection('users').document(uid).update(dict(enterpriseId=enterpriseId))
    except Exception as e:
        print(e)

def deleteManualProducts(shopId):
    try:
        docs = db.collection('manualProducts').where('activeShops', 'array_contains', shopId).get()
        for doc in docs:
            doc.reference.update(dict(activeShops=ArrayRemove([shopId])))
    except Exception as e:
        print(e)

def deleteOrders(uid, shopId):
    try:
        docs = db.collection('orders').where('uid', '==', uid).where('shopId', '==', shopId).get()
        for doc in docs:
            doc.reference.delete()
            deleteOrderItems(doc.id)
    except Exception as e:
        print(e)

def deleteProducts(uid, shopId):
    try:
        docs = db.collection('products').where('uid', '==', uid).where("shopId", "==", shopId).get()
        for doc in docs:
            doc.reference.delete()
    except Exception as e:
        print(e)

def deleteOrderItems(orderId):
    try:
        docs = db.collection('orderItems').where('orderId', '==', orderId).where.get()
        for doc in docs:
            doc.reference.delete()
    except Exception as e:
        print(e)

def deleteShops(uid):
    try:
        docs = db.collection('shops').where('uid', '==', uid).get()
        for doc in docs:
            db.collection("shopsCredentials").document(doc.id).delete()
            db.collection("fulfillmentServices").document(doc.id).delete()
            doc.reference.delete()
    except Exception as e:
        print(e)

def deleteOrderUpdates(shopId):
    try:
        db.collection('orderUpdates').document(shopId).delete()
    except Exception as e:
        print(e)

def deleteProductUpdates(shopId):
    try:
        db.collection('productUpdates').document(shopId).delete()
    except Exception as e:
        print(e)

def getEnterpriseAdmin(enterpriseId):
    try:
        ref = db.collection('enterprises').document(enterpriseId).get()
        if ref.exists:
            uid = ref.to_dict().get("admins", [])[0]
            return uid
    except Exception as e:
        print(e)
    return None


def updateUserTasks(uid:str, **kwargs):
    ref = db.document(f"users/{uid}/settings/tasks")
    ref.set(kwargs, merge=True)
    return kwargs