import sys

from mongo.get_conn import db_conn
import pandas as pd
import duckdb

class TableBuilder():
    def __init__(self) -> None:
        self.db = db_conn()
        data = self.db.beer_db
        data = data.find({}).sort("date", -1)
        df_dict = {}
        df_dict["beer_run_id"]=[]
        df_dict["sg"] = []
        df_dict["date"] = []
        df_dict["final_reading"] = []

        for record in data:
            df_dict["beer_run_id"].append(record["beer_run_id"])
            df_dict["sg"].append(record["sg"])
            df_dict["date"].append(record["date"])
            df_dict["final_reading"].append(record["final_reading"]) 

        self.df_dict = df_dict
        self.df = pd.DataFrame(data=self.df_dict)

    def done_runs_build(self, limit=10) -> pd.DataFrame:

        df = self.df
        sql = f"""
            SELECT  x.beer_run_id as beer_run_id, 
                    max(sg)  as max,
                    min(sg)  as min,
                    y.date as final_reading_date    
            FROM df x
            JOIN
            (   SELECT DISTINCT beer_run_id, date
                FROM df
                WHERE final_reading = 'True'
            ) y ON x.beer_run_id = y.beer_run_id
            GROUP BY x.beer_run_id, y.date
            ORDER BY x.beer_run_id desc
            LIMIT {limit}
        """
        df_sum = duckdb.sql(sql).df()
        sql = f"""
            SELECT  x.beer_run_id as "Beer Run",
                    x.max as "Max",
                    x.min as "Min", 
                    ROUND(((CAST (max AS INTEGER) - CAST(min AS INTEGER)) / 7.36) + 0.5, 2) AS "Alcohol Prediction +/- 0.5",
                    cast(final_reading_date as DATE) + INTERVAL 14 DAY as "Ready Date"

            FROM df_sum x
        """
        df_calc = duckdb.sql(sql).df()
        return df_calc
    
    def current_runs_build(self, limit=10) -> pd.DataFrame:
        df = self.df
        sql = f"""
            SELECT  x.beer_run_id as beer_run_id, 
                    max(sg)  as max,
                    min(sg)  as min,
                    min(cast(x.date as DATE)) as first_reading_date    
            FROM df x
            LEFT JOIN
            (   SELECT DISTINCT beer_run_id
                FROM df
                WHERE final_reading = 'True'
            ) y ON x.beer_run_id = y.beer_run_id
            WHERE y.beer_run_id is null
            GROUP BY x.beer_run_id
            ORDER BY x.beer_run_id desc
            LIMIT {limit}
        """
        df_sum = duckdb.sql(sql).df()
        sql = f"""
            SELECT  x.beer_run_id as "Beer Run",
                    x.max as "Max",
                    x.min as "Min", 
                    ROUND(((CAST (max AS INTEGER) - 1012) / 7.36) + 0.5, 2) AS "Alcohol Prediction (1012) +/- 0.5",
                    first_reading_date + INTERVAL 7 DAY as "Earliest Bottling/Kegging Date"

            FROM df_sum x
        """
        df_calc = duckdb.sql(sql).df()
        return df_calc