import sys
import time
from pathlib import Path

import cv2
from openvino.inference_engine import IECore
import matplotlib.cm
import matplotlib.pyplot as plt
import numpy as np
import streamlit as st
from PIL import Image
import tempfile


DEMO_IMAGE = 'dog-new.jpg'

DEMO_VIDEO = 'demo.mp4'


@st.cache
def normalize_minmax(data):
   
    return (data - data.min()) / (data.max() - data.min())

@st.cache
def convert_result_to_image(result, colormap="inferno"):
    
    cmap = matplotlib.cm.get_cmap(colormap)
    result = result.squeeze(0)
    result = normalize_minmax(result)
    result = cmap(result)[:, :, :3] * 255
    result = result.astype(np.uint8)
    return result

@st.cache
def to_rgb(image_data) -> np.ndarray:
    
    return cv2.cvtColor(image_data, cv2.COLOR_BGR2RGB)


st.title("Depth Estimation App")
st.sidebar.title('Depth Estimation')
st.sidebar.subheader('Parameters')

DEVICE = "CPU"
MODEL_FILE = "models/MiDaS_small.xml"

model_xml_path = Path(MODEL_FILE)


ie = IECore()
net = ie.read_network(model=model_xml_path, weights=model_xml_path.with_suffix(".bin"))
exec_net = ie.load_network(network=net, device_name=DEVICE)

input_key = list(exec_net.input_info)[0]
output_key = list(exec_net.outputs.keys())[0]

network_input_shape = exec_net.input_info[input_key].tensor_desc.dims
network_image_height, network_image_width = network_input_shape[2:]


app_mode = st.sidebar.selectbox('Choose the App mode',
['Run on Image','Run on Video'],index = 0)


if app_mode == "Run on Image":


    st.markdown('Running on Image')

    st.sidebar.text('Params for Image')
    st.markdown(
    """
    <style>
    [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
        width: 400px;
    }
    [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
        width: 400px;
        margin-left: -400px;
    }
    </style>
    """,
    unsafe_allow_html=True,
    )

    img_file_buffer = st.sidebar.file_uploader("Upload an image", type=[ "jpg", "jpeg",'png'])

    if img_file_buffer is not None:
        image = np.array(Image.open(img_file_buffer))

    else:
        demo_image = DEMO_IMAGE
        image = np.array(Image.open(demo_image))

    st.sidebar.text('Original Image')
    st.sidebar.image(image)
    resized_image = cv2.resize(src=image, dsize=(network_image_height, network_image_width))
    # reshape image to network input shape NCHW
    input_image = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0)


    result = exec_net.infer(inputs={input_key: input_image})[output_key]
    # convert network result of disparity map to an image that shows
    # distance as colors
    result_image = convert_result_to_image(result=result)
    # resize back to original image shape. cv2.resize expects shape
    # in (width, height), [::-1] reverses the (height, width) shape to match this.
    result_image = cv2.resize(result_image, image.shape[:2][::-1])


    st.subheader('Output Image')

    st.image(result_image,use_column_width= True)

if app_mode =='Run on Video':

    st.markdown('Running on Video')

    use_webcam = st.sidebar.button('Use Webcam')

    video_file_buffer = st.sidebar.file_uploader("Upload a video", type=[ "mp4", "mov",'avi','asf', 'm4v' ])

    tfflie = tempfile.NamedTemporaryFile(delete=False)

    stop_button = st.sidebar.button('Stop Processing')

    if stop_button:
        st.stop()



    if not video_file_buffer:
        if use_webcam:
            vid = cv2.VideoCapture(0)
            
        else:
            vid = cv2.VideoCapture(DEMO_VIDEO)
            tfflie.name = DEMO_VIDEO
    

        
    else:
        tfflie.write(video_file_buffer.read())
        vid = cv2.VideoCapture(tfflie.name)





    

    width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = int(vid.get(cv2.CAP_PROP_FPS))#codec = cv2.VideoWriter_fourcc(*FLAGS.output_format)
    codec = cv2.VideoWriter_fourcc('X','V','I','D')
    out = cv2.VideoWriter('output_depth.mp4', codec, fps, (width, height))

    start_time = time.perf_counter()
    total_inference_duration = 0
    stframe = st.empty()
    SCALE_OUTPUT = 1
    st.markdown("**Frame Rate**")
    kpi1_text = st.markdown("0")
    save_video = st.checkbox('Save video')

    while vid.isOpened():
        ret, image = vid.read()
        new_time = time.time()
        input_video_frame_height, input_video_frame_width = image.shape[:2]
        target_frame_height = int(input_video_frame_height * SCALE_OUTPUT)
        target_frame_width = int(input_video_frame_width * SCALE_OUTPUT)


        if not ret:
            vid.release()
            break
        resized_image = cv2.resize(src=image, dsize=(network_image_height, network_image_width))
        # reshape image to network input shape NCHW
        input_image = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0)

        inference_start_time = time.perf_counter()
        result = exec_net.infer(inputs={input_key: input_image})[output_key]
        inference_stop_time = time.perf_counter()
        inference_duration = inference_stop_time - inference_start_time
        total_inference_duration += inference_duration


        result_frame = to_rgb(convert_result_to_image(result))
        # Resize image and result to target frame shape
        result_frame = cv2.resize(result_frame, (target_frame_width, target_frame_height))
        image = cv2.resize(image, (target_frame_width, target_frame_height))
        # Put image and result side by side
        stacked_frame = np.vstack((image, result_frame))
        if save_video:
            out.write(stacked_frame)

        stframe.image(stacked_frame,channels = 'BGR',use_column_width=True)
        fps = 1.0/(time.time() - new_time)
        kpi1_text.write(f"<h1 style='text-align: center; color: red;'>{'{:.1f}'.format(fps)}</h1>", unsafe_allow_html=True)

        

    vid.release()
    out.release()
    cv2.destroyAllWindows()
    st.success('Video is Processed')
    st.stop()