from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse,StreamingResponse,Response
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
from csv_to_db import ImportCSV
import uvicorn
import asyncio
import hashlib
from pydantic import BaseModel
import cv2
import numpy as np
import base64
import io
import re
from PIL import Image
from typing import Generic, TypeVar,Dict,List,AnyStr,Any,Union
from fastapi.middleware.cors import CORSMiddleware
def readb64(uri):
   encoded_data = uri.split(',')[1]
   nparr = np.fromstring(base64.b64decode(encoded_data), np.uint8)
   img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
   return img
def find_revision_card(username,hashedvalue):
    found_revision_card = []
    revisioncards = list(importcsv.db.accountrevisioncards.find({"email": username}))[0]
    for revisioncard in revisioncards["revisioncards"]:
        checkhash =  revisioncards["email"] + revisioncard["subject"] + revisioncard["revisioncardtitle"]
        checkhash = hashlib.sha256(checkhash.encode()).hexdigest()[:31] # 15
        if checkhash == hashedvalue:
            found_revision_card.append(revisioncard)
    return found_revision_card
app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
def get_first_frame(imagebyteio):
    image = Image.open(imagebyteio)
    rgb_im = image.convert('RGB')
    img_byte_arr = io.BytesIO()
    rgb_im.save(img_byte_arr, format='PNG')
    img_byte_arr = img_byte_arr.getvalue()
    return img_byte_arr
importcsv = ImportCSV("RevisionBankDB")
templates = Jinja2Templates(directory="templates")
JSONObject = Dict[Any, Any]
JSONArray = List[Any]
JSONStructure = Union[JSONArray, JSONObject]

app.mount("/static", StaticFiles(directory="static"), name="static")
@app.post("/hashnotecard")
async def hashnotecard(data : JSONStructure = None):
    try:
        data = dict(data)
        plainvalue = data["email"] + data["subject"] + data["revisioncardtitle"]
        hashvalue = hashlib.sha256(plainvalue.encode()).hexdigest()[:31] # 15
        return {"message":hashvalue}
    except Exception as ex:
        return {"error":f"{type(ex)},{ex}"}
@app.get("/getcard")
async def getcard(request: Request, h:str,u:str):
    hashedvalue = h
    username = u
    #name = "test1.jpg"
    found_revision_card = find_revision_card(username,hashedvalue)
    try:
        revisioncarddetected = found_revision_card[0]
        #print(revisioncarddetected)
        #<!-- {{ url_for('static', path=name) }}-->
        return revisioncarddetected
    except IndexError as iex:
        print({"message":"revision card was not found."})

@app.get("/notecard", response_class=HTMLResponse)
async def notecard(request: Request, h:str,u:str):
    # TODO Add share=1|0 paraneter for security implementations later
    hashedvalue = h
    username = u
    #name = "test1.jpg"
    found_revision_card = find_revision_card(username,hashedvalue)
    try:
        revisioncarddetected = found_revision_card[0]
        #print(revisioncarddetected)
        #<!-- {{ url_for('static', path=name) }}-->
        return templates.TemplateResponse("hello.html", {"request": request,"hashvalue":hashedvalue,"username":username,"subject":revisioncarddetected["subject"],"revisioncardtitle":revisioncarddetected["revisioncardtitle"],"revisioncard":revisioncarddetected["revisioncard"],"revisioncardimgname":revisioncarddetected["revisioncardimgname"],"revisioncardimage":revisioncarddetected["revisioncardimage"]}) # "name":name
    except IndexError as iex:
        print({"message":"revision card was not found."})

@app.get("/getnotecard")
async def getnotecard(request: Request, h:str,u:str):
    # TODO Add share=1|0 paraneter for security implementations later
    hashedvalue = h
    username = u
    #name = "test1.jpg"
    found_revision_card = find_revision_card(username,hashedvalue)
    try:
        revisioncarddetected = found_revision_card[0]
        #print(revisioncarddetected)
        #<!-- {{ url_for('static', path=name) }}-->
        return revisioncarddetected
    except IndexError as iex:
        print({"message":"revision card was not found."})

@app.get("/notecardimage")
async def notecardimage(request: Request, h:str,u:str):
    try:
        # TODO Add share=1|0 paraneter for security implementations later
        # TODO Add Header to link to RevisionBank
        # TODO Make a share button on revisionbank that will generate the link.
        # TODO Add Favicon
        # TODO Maybe show videos
        hashedvalue = h
        username = u
        #name = "test1.jpg"
        found_revision_card = find_revision_card(username,hashedvalue)
        try:
            revisioncarddetected = found_revision_card[0]     
            if "data:image/gif;base64" in revisioncarddetected["revisioncardimage"][0]:
                imagebyteio = io.BytesIO(base64.b64decode(re.sub("data:image/gif;base64", '', revisioncarddetected["revisioncardimage"][0])))
                img_byte_arr= get_first_frame(imagebyteio)
                return Response(content = img_byte_arr, media_type="image/gif")
                #return Response(content = imagebyteio.read(), media_type="image/gif")
            elif "data:image/gif;base64" not in revisioncarddetected["revisioncardimage"][0]:
                imagecv2 = readb64(revisioncarddetected["revisioncardimage"][0])
                res, im_png = cv2.imencode(".png", imagecv2)
                return Response(content = im_png.tobytes(), media_type="image/png")
                #return StreamingResponse(io.BytesIO(im_png.tobytes()), media_type="image/png")
        except IndexError as iex:
            return {"message":"revision card was not found or no image"}
    except Exception as ex:
        return {"meesage":f"{type(ex)},{ex}"}
    


async def main():
    config = uvicorn.Config("main:app", port=7860, log_level="info",host="0.0.0.0",reload=True)
    server = uvicorn.Server(config)
    await server.serve()

if __name__ == "__main__":
    uvicorn.run("main:app", port=7860, log_level="info",host="0.0.0.0",reload=True)
    #asyncio.run(main())