import streamlit as st
import security
from streamlit_extras.add_vertical_space import add_vertical_space
import os
import streamlit as st
import pandas as pd
from io import StringIO
from datetime import datetime
import boto3
import util
import requests
import time
from sf_conn import get_client_names, get_secret, save_to_sf
from constants import USER_LIST
from util import logger

(REDIRECT_URI, create_batch_url, doczy_pipeline) = util.load_page_details(1)

user_list = USER_LIST
st.set_page_config(layout="wide")
# Sidebar contents
with st.sidebar:
    st.title("Doczy.AI ™")
    st.markdown(
        """
    ## About
    This app extracts data from contracts
 
    """
    )
    add_vertical_space(15)
    # st.write("Doczy")

# AARETE LOGO
x, y, z = st.columns([15, 2, 15])
with y:
    st.image("aaretelogo.png")

hide_img_fs = """
<style>
button[title="View fullscreen"]{
    visibility: hidden;}
</style>
"""
st.markdown(hide_img_fs, unsafe_allow_html=True)

_, c1 = st.columns([5, 1])
try:
    util.setup_page(REDIRECT_URI)
except:
    st.write("SSO Failed")
    st.session_state["user_info"] = {
        "mail": "maamseek@aarete.com",
        "displayName": "Mayank Aamseek",
    }  # RECOMMENDATION - Remove after dev phase
try:
    c1.write(f"User: **{st.session_state.user_info['displayName']}**")
    user_mail = st.session_state.user_info["mail"]
except KeyError as e:
    # Do we add a link to get to the login page here?
    st.write("Session Expired.")
    # st.write("Please sign-in to use this app.")
    auth_url = security.get_auth_url(REDIRECT_URI)
    st.markdown(
        f"<a href='{auth_url}' target='_self'>Sign In</a>", unsafe_allow_html=True
    )
    st.stop()


s3_client = boto3.client(
    "s3",
    region_name="us-east-2",
)

# # to be replaced with snowflake data
# client_list = ['doczy-ai-client-1', 'Delaware First Health, Inc.', 'Community Health Choice, Inc','CareSource Network Partners LLC',
#     'HealthNet of Cali', 'Oklahoma Complete Health, Inc', 'HealthFirst', 'Molina Healthcare of TX', 'AvMed', 'Arizona Care1st',
#     'WellCare New Jersey']

client_list, s3_paths = get_client_names()
client_s3_paths = dict(zip(client_list, s3_paths))

client_row = st.columns([0.1, 0.8])
with client_row[0]:
    st.write("**Client Name**")
with client_row[1]:
    client = st.selectbox(
        "Client Name", (client_list), label_visibility="collapsed", index=None
    )

if client:
    client_bucket = client_s3_paths.get(client)

    # to be deleted when buckets for different clients are ready; below line is added only for testing the corresponding DAG
    # client_bucket = 'doczyai-use2-d-cn1-s3-textract-processing-001'

    batch_objects = s3_client.list_objects_v2(
        Bucket=client_bucket, Prefix="contracts-landing-zone/", Delimiter="/"
    )

    batch_list = []
    for prefix in batch_objects["CommonPrefixes"]:
        batch_name = prefix["Prefix"][:-1].split("/")[-1]
        batch_objects2 = s3_client.list_objects_v2(
            Bucket=client_bucket,
            Prefix="contracts-landing-zone/" + batch_name + "/",
            Delimiter="/",
        )
        if "Contents" in batch_objects2 and len(batch_objects2["Contents"]) > 0:
            batch_list.append(prefix["Prefix"][:-1].split("/")[-1])

    # Hardcoded batch_list for testing purposes
    # batch_list = ['batch_020524103737', 'batch_090524131433', 'batch_090524131607', 'batch_100524123000', 'batch_130524064322',
    #               'batch_160524071331', 'batch_200524213550', 'batch_250424112237', 'batch_280524120530', 'batch_280524121721', 'batch_280524144222',
    #               'batch_290524123926', 'batch_290524164044', 'batch_310524102029', 'batch_310524124050', 'batch_310524162346', 'batch_310524162631']

    # Select Box for Applying Different Sort for the Batch List

    # if 'sorted_list' not in st.session_state:
    #     st.session_state.sorted_list = batch_list

    # def sort_list(ex_list, sort_by, order):
    #     if sort_by == 'Alphabetical':
    #         ex_list = sorted(ex_list, reverse=(order == 'Descending'))
    #     elif sort_by == 'Create Date':
    #         ex_list = ex_list if order == 'Ascending' else list(reversed(ex_list))

    #     return ex_list

    # col1, col2, col3, col4 = st.columns([0.5, 0.5, 0.5, 0.5])

    # with col1:
    #     sort_by = st.radio("**Sort Batch_IDs**", ('Alphabetical', 'Create Date'))

    # with col2:
    #     order = st.radio('', ('Ascending','Descending'))

    # with col3:
    #     add_vertical_space(2)
    #     if st.button('Apply'):
    #         st.session_state.sorted_list = sort_list(batch_list, sort_by, order)

    path_row = st.columns([0.1, 0.8])
    with path_row[0]:
        st.write("**Batch ID**")
    with path_row[1]:
        batch_id = st.selectbox(
            "**Batch ID**",
            reversed(batch_list),
            label_visibility="collapsed",
            index=None,
        )

    if not batch_id:
        batch_id = "None"

    checks = st.columns([0.1, 0.12, 0.12, 0.12, 0.12, 0.12, 0.12, 0.12])
    with checks[0]:
        st.write("**Group No.**")

    with checks[1]:
        a = st.checkbox("Unique Key", key=str(1), args="Unique")
    with checks[2]:
        b = st.checkbox("Pricing Before Carveouts", key=str(2))
    with checks[3]:
        c = st.checkbox("Contract Related", key=str(3))
    with checks[4]:
        d = st.checkbox("Provider", key=str(4))
    with checks[5]:
        e = st.checkbox("Timeline", key=str(5))
    with checks[6]:
        f = st.checkbox("Carveout Indicator", key=str(6))
    with checks[7]:
        g = st.checkbox("Carveout Methodology", key=str(7))

    add_vertical_space(1)

    df = pd.DataFrame(
        columns=[
            "Contract Name",
            "Unique Key",
            "Pricing Before Carveouts",
            "Contract Related",
            "Provider",
            "Timeline",
            "Carveout Indicator",
            "Carveout Methodology",
        ]
    )
    file_list = []
    file_objects = s3_client.list_objects_v2(
        Bucket=client_bucket,
        Prefix="contracts-landing-zone/" + batch_id + "/",
        Delimiter="/",
    )

    # Hardcoded file_list for testing purposes
    # file_list = ['Boilerplate_TX Amendment Mission Health Network effective_040114 MU.pdf', 'Custom_TX - MP AMENDMENT - MISSION HEALTH NETWORK - MU.pdf',
    #              'Delaware First Health_First State Homecare Agency_212260_7 MU.pdf', 'Molina Healthcare of Texas, Inc. Amendment 4 - HIX ACA__EFF 01012016_MU.pdf']

    if st.button("Read the contracts from Path"):
        for obj in file_objects.get("Contents", []):
            if not obj["Key"].endswith("/"):
                file_list.append(obj["Key"].split("/")[-1])

        df["Contract Name"] = file_list
        # df['Request ID'] = range(len(file_list))
        # df['Contract ID'] = file_list
        df["Unique Key"] = a
        df["Pricing Before Carveouts"] = b
        df["Contract Related"] = c
        df["Provider"] = d
        df["Timeline"] = e
        df["Carveout Indicator"] = f
        df["Carveout Methodology"] = g
        dir_path = os.path.dirname(os.path.realpath(__file__))
        print(f"DEBUGGING: PWD= {dir_path}")
        df.to_csv("temp1.csv", index=False)

    add_vertical_space(1)
    df2 = pd.read_csv("temp1.csv")
    edited_df = st.data_editor(df2)

    edited_df["REQUEST_USER"] = user_mail
    edited_df["LATEST_FLAG BOOLEAN"] = True
    edited_df["PIPELINE_KICKOFF_DATETIME"] = datetime.now().strftime(
        "%Y-%m-%d %H:%M:%S"
    )
    edited_df["REQUEST_DATETIME"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    @st.cache_data
    def convert_df(df):
        return df.to_csv(index=False).encode("utf-8")

    csv = convert_df(edited_df)
    # edited_df = edited_df.reset_index()  # make sure indexes pair with number of rows

    # additional_info = pd.DataFrame(columns=['REQUEST_ID','T_DRIVE_PATH','CLIENT_NAME'
    # , 'GROUP_NAME', 'REQUEST_USERNAME', 'REQUEST_DATETIME'])
    additional_info = pd.DataFrame(
        columns=["CLIENT_NAME", "BATCH_ID", "REQUEST_USERNAME", "REQUEST_DATETIME"]
    )
    additional_info.loc[0] = [
        client,
        batch_id,
        st.session_state.user_info["mail"],
        datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
    ]
    st.write(additional_info)

    st.session_state.contract_count = 0
    contract_list = []
    for index, row in edited_df.iterrows():
        allow_run_for_contract = False
        group_list = []
        if row["Unique Key"]:
            group_list.append("A")
            allow_run_for_contract = True
        if row["Pricing Before Carveouts"]:
            group_list.append("B")
            allow_run_for_contract = True
        if row["Contract Related"]:
            group_list.append("C")
            allow_run_for_contract = True
        if row["Provider"]:
            group_list.append("D")
            allow_run_for_contract = True
        if row["Timeline"]:
            group_list.append("E")
            allow_run_for_contract = True
        if row["Carveout Indicator"]:
            group_list.append("F")
            allow_run_for_contract = True
        if row["Carveout Methodology"]:
            group_list.append("G")
            allow_run_for_contract = True
        if allow_run_for_contract:
            st.session_state.contract_count += 1
        entry_dict = {
            "contract_name": row["Contract Name"],
            "groups": group_list,
            "contract_source_path": "contracts-landing-zone/"
            + batch_id
            + "/"
            + row["Contract Name"],
        }
        contract_list.append(entry_dict)

    myobj = {
        "s3_bucket": client_bucket,
        "batch_id": batch_id,
        "client_name": client,
        "username": user_mail,
        "contract_list": contract_list,
    }

    buttons = st.columns([0.8, 0.2])
    with buttons[0]:
        st.download_button(
            "Download Table", csv, "file.csv", "text/csv", key="download-csv"
        )
    with buttons[1]:
        if st.button("Run Doczy.AI Pipeline"):
            if not st.session_state.contract_count == len(edited_df):
                st.error("Select at least one Group No. for every Contract")
            else:
                with st.spinner("Running..."):
                    # csv_buf = StringIO()
                    # additional_info.to_csv(csv_buf, header=True, index=False)
                    # csv_buf.seek(0)
                    # s3_client.put_object(Bucket='doczy-dev-infra-raw-data-ingestion', Body=csv_buf.getvalue(), Key='training_interface/request_submission.csv')
                    # csv_buf = StringIO()
                    # edited_df.to_csv(csv_buf, header=True, index=False)
                    # csv_buf.seek(0)
                    # s3_client.put_object(Bucket='doczy-dev-infra-raw-data-ingestion', Body=csv_buf.getvalue(), Key='training_interface/contract_config.csv')
                    # try:
                    #     save_to_sf('load_request_and_contract_submissions', request_submission_file_name = "request_submission.csv", contract_config_file_name = "contract_config.csv")
                    # except Exception as e:
                    #     st.write(e)
                    response = requests.post(doczy_pipeline, json=myobj)
                if response.status_code >= 200 and response.status_code < 300:
                    success_message = """
                    <div style="text-align: center; font-size: 24px; color: green;">
                        Pipeline Success
                    </div>
                    """
                    st.markdown(success_message, unsafe_allow_html=True)
                    # st.write(myobj)
                else:
                    failure_message = """
                    <div style="text-align: center; font-size: 24px; color: red;">
                        Pipeline Failed
                    </div>
                    """
                    st.markdown(failure_message, unsafe_allow_html=True)
                # st.write(response.text)