import pandas as pd
import numpy as np
from datetime import datetime
from typing import Optional, List, Dict

# === Main Compute Function ===

def compute_metrics_from_dataset(tid: str, sid: int, df: pd.DataFrame,
                                 sdt: datetime, edt: datetime,
                                 res: str = 'hourly',
                                 dur: Optional[str] = None,
                                 expected_config_count: Optional[int] = None,
                                 previous_mean: Optional[float] = None) -> pd.DataFrame:
    """
    Compute all KPIs from 1-minute sample data grouped to an hourly resolution.
    """

    if df.empty:
        return pd.DataFrame()

    metrics: List[Dict] = []

    def add_metric(name: str, value: Optional[float]):
        metrics.append({
            'tid': tid,
            'sid': sid,
            'year': sdt.year,
            'month': sdt.month,
            'dayofmonth': sdt.day,
            'hourofday': sdt.hour,
            'metric_name': name,
            'metric_value': round(value, 4) if pd.notnull(value) else None,
            'sdt': sdt,
            'edt': edt,
            'res': res,
            'dur': dur or ''
        })

    sv = df['samplevalue'].dropna()
    ec_hist = df['expectedcount'].mean() if 'expectedcount' in df.columns else None
    ec_conf = expected_config_count

    # === 📌 Base Metrics ===
    add_metric('Actual_Count', len(sv))
    add_metric('Expected_Config_Count', ec_conf)
    add_metric('Expected_Hist_Count', ec_hist)

    if ec_conf:
        add_metric('Coverage_Pct_Config', (len(sv) * 100.0 / ec_conf))
        add_metric('Missing_Pct_Config', 100.0 - (len(sv) * 100.0 / ec_conf))
    else:
        add_metric('Coverage_Pct_Config', None)
        add_metric('Missing_Pct_Config', None)

    if ec_hist:
        add_metric('Coverage_Pct_Hist', (len(sv) * 100.0 / ec_hist))
        add_metric('Missing_Pct_Hist', 100.0 - (len(sv) * 100.0 / ec_hist))
    else:
        add_metric('Coverage_Pct_Hist', None)
        add_metric('Missing_Pct_Hist', None)

    add_metric('Actual_Mean', sv.mean())
    add_metric('Actual_Median', sv.median())
    add_metric('Actual_Mode', sv.mode().iloc[0] if not sv.mode().empty else None)
    add_metric('Actual_Min', sv.min())
    add_metric('Actual_Max', sv.max())
    add_metric('Actual_Range', sv.max() - sv.min())

    # === ⚙️ Behavior / Quality KPIs ===
    flat_pct = (sv.diff().fillna(1) == 0).sum() * 100.0 / len(sv)
    add_metric('Flatline_Pct', flat_pct)
    outliers = ((sv - sv.mean()).abs() > (3 * sv.std())).sum()
    add_metric('Outlier_Count', outliers)
    add_metric('Value_Constant', 1 if sv.min() == sv.max() else 0)

    # === 📊 Distribution Shape KPIs ===
    add_metric('Stddev', sv.std())
    add_metric('Variance', sv.var())
    add_metric('IQR', sv.quantile(0.75) - sv.quantile(0.25))
    add_metric('Skewness', sv.skew())
    add_metric('Kurtosis', sv.kurtosis())
    add_metric('Percentile_95', sv.quantile(0.95))

    # === 📈 Trend & Change KPIs ===
    if 'timeofsample' in df.columns:
        df_sorted = df.sort_values('timeofsample')
        x = pd.to_datetime(df_sorted['timeofsample']).astype(np.int64) // 10**9
        y = df_sorted['samplevalue']
        if len(x) > 1:
            slope = np.polyfit(x, y, 1)[0]
            add_metric('Slope_Trend', slope)
        else:
            add_metric('Slope_Trend', None)
    else:
        add_metric('Slope_Trend', None)

    # Drift-related KPIs
    if previous_mean and sv.std() > 0:
        drift = (sv.mean() - previous_mean) / sv.std()
        add_metric('Drift_Score', drift)
        add_metric('Momentum_Trend', sv.mean() - previous_mean)
    else:
        add_metric('Drift_Score', None)
        add_metric('Momentum_Trend', None)

    # Rate of change
    duration_seconds = (edt - sdt).total_seconds()
    add_metric('Rate_Change', (sv.max() - sv.min()) / duration_seconds if duration_seconds > 0 else None)

    # Z-score
    zscore_max = ((sv - sv.mean()).abs() / sv.std()).max() if sv.std() > 0 else None
    add_metric('Zscore_Max', zscore_max)

    return pd.DataFrame(metrics)

@startuml
!theme vibrant
skinparam defaultFontName Consolas
skinparam defaultFontSize 22

title Metrics Module – Layered Architecture with Notes

' Define layers
rectangle "🧑‍💼 User Layer" {
  actor User
}

package "🐍 Application Layer (Python)" as app {
  control "[def get_data()]" as PMGet #lightblue
  component "[def compute_metrics()]" as Compute #lightgreen
  control "[def put_metrics()]" as PMPut #lightyellow

}

  note as NoteCompute #lightgreen
    Calculates KPIs on DataFrame including:\n
    - Base (count, mean, median, etc.)\n
    - Behavior / Quality (flatline, outliers)\n
    - Distribution shape (skewness, kurtosis)\n
    - Trend / drift metrics (slope, momentum)
  end note

package "🗄️ Data Layer (PostgreSQL)" as dbs {

  control "[function pgsql_get_dataset()]" as PGGet #lightblue
  note left of PMGet  #lightblue
    Retrieves raw sensor data from PostgreSQL
    - Calls pgsql_get_dataset()
    - Returns DataFrame with 5 days historical data
  end note
  control "[pgsql_put_metrics()]" as PGPut #lightyellow
  note right of PMPut #lightyellow
    Serializes and stores computed KPIs\n
    - Calls pgsql_put_metrics()\n
    - Upserts metrics into metrics_result table
  end note
}
  database "ADS" as ads #lightgrey
app .d[hidden]. dbs

User -d-> PMGet : <b>[1.]</b> Run(tid,sid...) 
PMGet <.d. PGGet : <b>[2.]</b>  Get_dataset(sid...)
PGGet <.d. ads : <b>[3.]</b>  SELECT raw data for last 5 similar weekdays
PMGet .r.> Compute : [4.] compute_metrics(df)
Compute .r.> PMPut : [5.] put_metrics(metrics_df)
PMPut ..> PGPut : <b>[6.]</b> Store metrics in DB
PGPut ..> ads : <b>[7.]</b> INSERT/UPDATE metrics_result
User <-- PMPut : <b>[8.]</b> OK


NoteCompute =d[#lightgreen]=> app

@enduml