# TODO
#  convert etcd3 usage to etcd3_wrapper

import etcd3
import json

from helper import check_otp
from flask import Flask
from flask_restful import Resource, Api, reqparse
from decouple import config
from uuid import uuid4
from etcd3_wrapper import Etcd3Wrapper

app = Flask(__name__)
api = Api(app)

etcd_client = etcd3.client(host=config("ETCD_HOST"), port=int(config("ETCD_PORT")))
client = Etcd3Wrapper()

createvm_argparser = reqparse.RequestParser()
createvm_argparser.add_argument("name", type=str, required=True)
createvm_argparser.add_argument("realm", type=str, required=True)
createvm_argparser.add_argument("seed", type=str, required=True)
createvm_argparser.add_argument("specs", type=dict, required=True)

deletevm_argparser = reqparse.RequestParser()
deletevm_argparser.add_argument("name", type=str, required=True)
deletevm_argparser.add_argument("realm", type=str, required=True)
deletevm_argparser.add_argument("seed", type=str, required=True)
deletevm_argparser.add_argument("vmid", type=str, required=True)

vmstatus_argparser = reqparse.RequestParser()
vmstatus_argparser.add_argument("id", type=str, required=True)

createimage_argparser = reqparse.RequestParser()
createimage_argparser.add_argument("uuid", type=str, required=True)
createimage_argparser.add_argument("name", type=str, required=True)
createimage_argparser.add_argument("image_store", type=str, required=True)


class CreateVM(Resource):
    def post(self):
        createvm_args = createvm_argparser.parse_args()
        name, realm, seed, specs = createvm_args.name, createvm_args.realm,\
                                   createvm_args.seed, createvm_args.specs

        if check_otp(name, realm, seed) == 200:
            # User is good

            vm_entry = {"owner": name,
                        "specs": specs,
                        "hostname": "",
                        "status": "REQUESTED_NEW"}

            etcd_client.put(f"/v1/vm/{uuid4().hex}", json.dumps(vm_entry))

            return {"message": "VM Creation Queued"}, 200
        else:
            return {"message": "Invalid Credentials"}, 400


class DeleteVM(Resource):
    def post(self):
        deletevm_args = deletevm_argparser.parse_args()
        name, realm, seed, vmid = deletevm_args.name, deletevm_args.realm,\
                                  deletevm_args.seed, deletevm_args.vmid

        if check_otp(name, realm, seed) == 200:
            # User is good

            vmentry_etcd = etcd_client.get(f"/v1/vm/{vmid}")[0]
            if vmentry_etcd:
                vmentry_etcd = json.loads(vmentry_etcd)
                vmentry_etcd["status"] = "REQUEST_DELETE"

                etcd_client.put(f"/v1/vm/{vmid}", json.dumps(vmentry_etcd))

                return {"message": "VM Deletion Queued"}, 200
            else:
                return {"message": "Invalid VM ID"}
        else:
            return {"message": "Invalid Credentials"}, 400


class VmStatus(Resource):
    def get(self):
        args = vmstatus_argparser.parse_args()
        r = etcd_client.get(f"/v1/vm/{args.id}")[0]
        if r:
            r = dict(json.loads(r.decode("utf-8")))
            return r
        return {"Message": "Not Found"}


class CreateImage(Resource):
    def post(self):
        image_stores = list(client.get_prefix("/v1/image_store/"))
        args = createimage_argparser.parse_args()
        image_file_uuid = args.uuid
        image_store_name = args.image_store

        file_entry = client.get(f"/v1/files/{image_file_uuid}")
        if file_entry is None:
            return {
                "Message":
                f"Image File with uuid '{image_file_uuid}' Not Found"}, 400

        file_entry_value = json.loads(file_entry.value)

        image_store = list(filter(lambda s: json.loads(s.value)["name"] == image_store_name, image_stores))
        if not image_store:
            return {"Message": f"Store '{image_store_name}' does not exists"}, 400

        image_store = image_store[0]
        image_entry_json = {
            "status": "TO_BE_CREATED",
            "owner": file_entry_value["owner"],
            "filename": file_entry_value["filename"],
            "name": args.name,
            "store_name": image_store_name
        }
        client.put(f"/v1/image/{image_file_uuid}", json.dumps(image_entry_json))

        return {"Message": "Image successfully created"}


api.add_resource(CreateVM, "/vm/create")
api.add_resource(DeleteVM, "/vm/delete")
api.add_resource(VmStatus, "/vm/status")
api.add_resource(CreateImage, "/image/create")


if __name__ == "__main__":
    app.run(host="::", debug=True)