API_KEY = "your-api-key"

import json
import requests

API_URL = "https://api.toqua.ai"

url = "https://api.toqua.ai/ships/"
headers = {"accept": "application/json", "X-API-Key": API_KEY}
response = requests.get(url, headers=headers)

print(json.dumps(response.json(), indent=2))

IMO_NUMBER = "your-imo-number"

import pandas as pd
from IPython.display import display
from typing import List, Dict, Tuple
import ssl
import json
from urllib.request import Request, urlopen
from urllib.error import HTTPError
import requests
import numpy as np
from tqdm import tqdm
import time
import matplotlib.pyplot as plt
from plotly.subplots import make_subplots
import plotly.graph_objects as go

df = pd.read_csv("./example_sensor_data.csv")

display(df.head(10))

columns_to_keep = ["datetime_end", "imo_number", "heading", "me_fo_consumption", "me_power", "sog", "draft_avg", "fo_ncv", "current_speed", "current_dir",
    "wave_height", "wave_dir", "wind_speed", "wind_dir"]

data_filtered = df[columns_to_keep].copy()

display(data_filtered.head(10))

def get_voyages(numeric_imo: str, api_key: str, voyage_type: str = "auto") -> List[Dict]:
    url = f"https://api.toqua.ai/ships/{numeric_imo}/voyages"
    headers = {
        "accept": "application/json",
        "X-API-Key": api_key,
    }

    response = requests.get(url, headers=headers)
    
    if response.status_code == 404:
        return []
    response.raise_for_status()
    
    all_voys = response.json().get("voyages", [])
    filtered_voys = [v for v in all_voys if v.get("voyage_id_source") == voyage_type]
    return filtered_voys

def get_voyage_times(voyage_id: str, numeric_imo: str, api_key: str, voyage_type: str = "customer") -> Tuple[pd.Timestamp, pd.Timestamp]:
    voyages = get_voyages(numeric_imo, api_key, voyage_type=voyage_type)
    for v in voyages:
        if v["voyage_id"] == voyage_id:
            return (
                pd.to_datetime(v["departure"]["datetime"]),
                pd.to_datetime(v["arrival"]["datetime"])
            )
    raise ValueError(f"Voyage {voyage_id!r} not found for {numeric_imo}")

def assign_voyage_ids_to_df(df: pd.DataFrame, numeric_imo: str, api_key: str, voyage_type: str = "customer") -> pd.DataFrame:
    voyages = get_voyages(numeric_imo, api_key, voyage_type=voyage_type)
    print(f"📦 Found {len(voyages)} {voyage_type} voyages")

    df["datetime_end"] = pd.to_datetime(df["datetime_end"])
    if df["datetime_end"].dt.tz is None:
        df["datetime_end"] = df["datetime_end"].dt.tz_localize("UTC")

    df["voyage_id"] = None  # initialize

    for v in voyages:
        voyage_id = v.get("voyage_id")
        dep_raw = v.get("departure", {}).get("datetime")
        arr_raw = v.get("arrival", {}).get("datetime")

        if not dep_raw or not arr_raw:
            print(f"⚠️ Skipping voyage {voyage_id}: missing times")
            continue

        try:
            dep = pd.to_datetime(dep_raw)
            arr = pd.to_datetime(arr_raw)

            if dep.tzinfo is None:
                dep = dep.tz_localize("UTC")
            if arr.tzinfo is None:
                arr = arr.tz_localize("UTC")

            mask = (df["datetime_end"] >= dep) & (df["datetime_end"] <= arr)
            df.loc[mask, "voyage_id"] = voyage_id
            print(f"✅ Assigned to voyage {voyage_id}: {mask.sum()} rows")
        except Exception as e:
            print(f"❌ Error tagging voyage {voyage_id}: {e}")

    df["voyage_id"] = df["voyage_id"].fillna("0")
    return df

data_filtered_voyage = assign_voyage_ids_to_df(data_filtered,IMO_NUMBER, API_KEY, voyage_type= "auto")

avg_draft_per_voyage = (data_filtered_voyage.groupby("voyage_id", dropna=False)["draft_avg"].mean().reset_index().rename(columns={"draft_avg": "avg_draft_avg"}))

ballast_draft = ship_info.get("ballast_draft")

voyage_metadata = get_voyages(IMO_NUMBER, API_KEY, voyage_type="auto")

# create a dataframe with voyage_id and voyage_period
voyage_dates = []
for v in voyage_metadata:
    voyage_id = v["voyage_id"]
    dep = v.get("departure", {}).get("datetime")
    arr = v.get("arrival", {}).get("datetime")
    if dep and arr:
        dep_date = pd.to_datetime(dep).strftime("%Y-%m-%d")
        arr_date = pd.to_datetime(arr).strftime("%Y-%m-%d")
        voyage_dates.append({
            "voyage_id": voyage_id,
            "voyage_period": f"{dep_date} → {arr_date}"
        })

voyage_dates_df = pd.DataFrame(voyage_dates)

# merge voyage period into the average draft dataframe
avg_draft_per_voyage = avg_draft_per_voyage.merge(voyage_dates_df,on="voyage_id",how="left")

# Decide draft mode: 'laden' or 'ballast'
def classify_draft_mode(row, ballast_draft, tolerance=1):
    if pd.isna(row["avg_draft_avg"]):
        return "unknown"
    return "ballast" if row["avg_draft_avg"] <= ballast_draft + tolerance else "laden"

avg_draft_per_voyage["draft_mode"] = avg_draft_per_voyage.apply(
    lambda row: classify_draft_mode(row, ballast_draft, tolerance=1),
    axis=1
)

# reorder columns as requested
avg_draft_per_voyage = avg_draft_per_voyage[["voyage_id", "voyage_period", "avg_draft_avg", "draft_mode"]]

display(avg_draft_per_voyage)

data_with_draft_info = data_filtered_voyage.merge(avg_draft_per_voyage[["voyage_id", "avg_draft_avg", "draft_mode"]], on="voyage_id", how="left")

missing_counts = data_with_draft_info.isna().sum()
print(missing_counts)

def get_ship_metadata(imo_number: str, api_key: str) -> Dict:
    url = f"https://api.toqua.ai/ships/{imo_number}"
    headers = {
        "accept": "application/json",
        "X-API-Key": api_key
    }
    response = requests.get(url, headers=headers)
    if response.ok:
        return response.json()
    else:
        raise Exception(f"❌ API Error {response.status_code}: {response.text}")

def get_predict_url(imo_number: str) -> str:
    return f"https://api.toqua.ai/ships/{imo_number}/models/latest/predict"

ship_info = get_ship_metadata(IMO_NUMBER, API_KEY)
ballast_draft = ship_info.get("ballast_draft")

predict_url = get_predict_url(IMO_NUMBER)

# necessary variables doing prediction
feature_map = {
    "sog": "sog",
    "wave_direction": "wave_dir",
    "wave_height": "wave_height",
    "wind_direction": "wind_dir",
    "wind_speed": "wind_speed",
    "current_direction": "current_dir",
    "current_speed": "current_speed",
    "draft_avg": "draft_avg",
    "fuel_specific_energy": "fo_ncv"
}

# determining neutral value draft_avg
ship_url = f"https://api.toqua.ai/ships/{IMO_NUMBER}"
ship_response = requests.get(ship_url, headers=headers)
if ship_response.ok:
    ship_info = ship_response.json()
    ballast_draft = ship_info.get("ballast_draft")
else:
    raise Exception(f"❌ API Error {ship_response.status_code}: {ship_response.text}")

laden_draft = ship_info.get("laden_draft")
# neutral values for decomposition
neutral_values = {
    "wind_speed": 0,
    "wave_height": 0,
    "current_speed": 0,
    "fuel_specific_energy": 41.6
}

measured_col = "me_fo_consumption"

# send a batch of rows to the API and return predicted ME FO consumption (= fuel_consumption)
def predict_batch(df_chunk, max_retries=3, delay=5): 
    api_input = {
        "data": {api_name: df_chunk[df_col].tolist()
                 for api_name, df_col in feature_map.items()}
    }
    for attempt in range(1, max_retries + 1):
        try:
            response = requests.post(predict_url, headers=headers, json=api_input, timeout=60)
            if response.ok:
                predictions = response.json()
                pred_list = predictions.get("me_fo_consumption", [None] * len(df_chunk))
                clean_list = [p if p is not None else np.nan for p in pred_list]
                return pd.Series(clean_list, index=df_chunk.index)
            elif response.status_code >= 500:
                print(f"⚠️ API error {response.status_code} on attempt {attempt}. Retrying in {delay}s...")
                time.sleep(delay)
            else:
                print(f"❌ API Error {response.status_code}: {response.text}")
                break 
        except requests.exceptions.RequestException as e:
            print(f"⚠️ Request failed on attempt {attempt}: {e}. Retrying in {delay}s...")
            time.sleep(delay)
    print("❌ Max retries reached. Returning NaNs for this chunk.")
    return pd.Series([np.nan] * len(df_chunk), index=df_chunk.index)

def compute_contributions_batched(df, chunk_size):
    all_chunks = []
    for start in range(0, len(df), chunk_size):
        end = min(start + chunk_size, len(df))
        df_chunk = df.iloc[start:end].copy()
        print(f"\n🔹 Processing rows {start} to {end - 1}...")
        df_chunk.replace([np.inf, -np.inf], np.nan, inplace=True)
        df_chunk.fillna(0, inplace=True)

        # 🔹 Baseline prediction
        print("📡 Sending baseline API request...")
        baseline_pred = predict_batch(df_chunk)
        df_chunk["predicted_consumption"] = baseline_pred

        # 🔹 Neutralized predictions
        for var in list(neutral_values.keys()) + ["draft_avg"]:
            print(f"📡 Sending API request with '{var}' neutralized...")
            df_neutralized = df_chunk.copy()
            df_col_name = feature_map.get(var, var)

            if var == "draft_avg":
                df_neutralized[df_col_name] = df_chunk.apply(
                    lambda row: ballast_draft if row["draft_mode"] == "ballast" else laden_draft,
                    axis=1
                )
            else:
                df_neutralized[df_col_name] = neutral_values[var]

            neutral_pred = predict_batch(df_neutralized)
            contrib_col = f"contrib_{var}"
            df_chunk[contrib_col] = df_chunk["predicted_consumption"] - neutral_pred
            df_chunk[f"{contrib_col}_pct"] = (
                df_chunk[contrib_col] / df_chunk["predicted_consumption"] * 100
            )


        all_chunks.append(df_chunk)
    df_result = pd.concat(all_chunks, ignore_index=True)
    print(f"\n✅ All predictions completed: {df_result.shape[0]} rows.")
    return df_result


df_results = compute_contributions_batched(data_with_draft_info, chunk_size = 10000)

selected_columns = ["datetime_end", "me_fo_consumption", "predicted_consumption",
    "contrib_wind_speed", "contrib_wind_speed_pct",
    "contrib_wave_height", "contrib_wave_height_pct",
    "contrib_current_speed", "contrib_current_speed_pct",
    "contrib_draft_avg", "contrib_draft_avg_pct",
    "contrib_fuel_specific_energy", "contrib_fuel_specific_energy_pct"
]
summary_df = df_results[selected_columns].copy()
display(summary_df.head(10))

# looking up different periods, every period has its own fouling percentage
def get_fouling_periods(imo_number: str, api_key: str) -> pd.DataFrame:
    """Extract fouling periods from performance_over_time (calibrated)."""
    url = f"https://api.toqua.ai/performance/{imo_number}"
    headers = {
        "accept": "application/json",
        "X-API-Key": api_key
    }

    response = requests.get(url, headers=headers, timeout=30)
    if not response.ok:
        raise Exception(f"❌ API Error {response.status_code}: {response.text}")

    perf_data = response.json()
    perf_times = perf_data.get("performance_over_time", {})

    starts = perf_times.get("datetime_start", [])
    ends = perf_times.get("datetime_end", [])
    percentages = perf_times.get("calibrated_excess_fuel_consumption_percentage", [])

    fouling_periods = []
    for start_str, end_str, percent in zip(starts, ends, percentages):
        if start_str and end_str and percent is not None:
            start = pd.to_datetime(start_str)
            end = pd.to_datetime(end_str)
            fouling_pct = percent / 100  # Convert % to fraction

            fouling_periods.append({
                "start": start,
                "end": end,
                "fouling_pct": fouling_pct
            })

    return pd.DataFrame(fouling_periods)


# get fouling periods
periods_df = get_fouling_periods(IMO_NUMBER, API_KEY)
print("📦 Fouling periods found (from performance_over_time):\n", periods_df)

# map fouling effects to each observation
def get_fouling_pct(timestamp):
    """Return fouling percentage for a timestamp."""
    for _, row in periods_df.iterrows():
        if row["start"] <= timestamp <= row["end"]:
            return row["fouling_pct"]
    return 0 

df_results["fouling_pct"] = df_results["datetime_end"].apply(get_fouling_pct)

selected_columns = ["datetime_end","me_fo_consumption", "predicted_consumption", "fouling_pct"]
summary_df = df_results[selected_columns].copy()
display(summary_df.head(10))

percent_cols = ["contrib_wind_speed_pct", "contrib_wave_height_pct", "contrib_current_speed_pct", "contrib_draft_avg_pct", "contrib_fuel_specific_energy_pct", "fouling_pct"]

for pct_col in percent_cols:
    abs_col = pct_col.replace("_pct", "")  
    abs_col_full = f"abs_{abs_col}"       
    df_results[abs_col_full] = df_results["me_fo_consumption"] * df_results[pct_col] / 100

abs_contrib_cols = [f"abs_{col.replace('_pct', '')}" for col in percent_cols]

df_results["total_modeled_contrib"] = df_results[abs_contrib_cols].sum(axis=1)
df_results["fuel_calm_water"] = df_results["me_fo_consumption"] - df_results["total_modeled_contrib"]

selected_columns = ["datetime_end","me_fo_consumption", "predicted_consumption", 
    "abs_contrib_wind_speed", "abs_contrib_wave_height",
    "abs_contrib_current_speed", "abs_contrib_draft_avg",
    "abs_contrib_fuel_specific_energy", "abs_fouling",
    "total_modeled_contrib", "fuel_calm_water"]
summary_df = df_results[selected_columns].copy()
display(summary_df.head(10))

#  define your columns with fuel rate (mt/day) 
rate_columns = [
    'fuel_calm_water',
    'abs_contrib_wind_speed',
    'abs_contrib_wave_height',
    'abs_contrib_current_speed',
    'abs_contrib_draft_avg',
    'abs_contrib_fuel_specific_energy',
    'abs_fouling'
]

# convert timestamp to datetime and extract date 
df_results['datetime_end'] = pd.to_datetime(df_results['datetime_end'])
df_results['date'] = df_results['datetime_end'].dt.date

# flatten voyage_id if needed 
df_results['voyage_id'] = df_results['voyage_id'].apply(lambda x: x[0] if isinstance(x, (list, tuple)) else x)

# convert rate columns to 5-minute fuel consumption 
conversion_factor = 5 / 1440  # 5 minutes in fraction of a day
for col in rate_columns:
    df_results[f'{col}_interval'] = df[col] * conversion_factor

selected_columns = ["datetime_end","me_fo_consumption", "predicted_consumption", 
    "abs_contrib_wind_speed_interval", "abs_contrib_wave_height_interval",
    "abs_contrib_current_speed_interval", "abs_contrib_draft_avg_interval",
    "abs_contrib_fuel_specific_energy_interval", "abs_fouling_interval",
    "fuel_calm_water_interval"]
summary_df = df_results[selected_columns].copy()

display(summary_df.head(10))

# determine dominant voyage_id per day 
dominant_voyage = (
    df.groupby(['date', 'voyage_id'])
    .size()
    .reset_index(name='count')
    .sort_values(['date', 'count'], ascending=[True, False])
    .drop_duplicates('date')
    .set_index('date')['voyage_id']
)

# aggregate daily fuel consumption + average SOG 🔧
daily_agg = df.groupby('date').agg({
    **{f'{col}_interval': 'sum' for col in rate_columns},
    'sog': 'mean'  # 🔧 this is the added line
}).reset_index()

# add dominant voyage_id 
daily_agg['voyage_id'] = daily_agg['date'].map(dominant_voyage)

# reorder columns 🔧
final_columns = ['date', 'voyage_id', 'sog'] + [f'{col}_interval' for col in rate_columns]
daily_agg = daily_agg[final_columns]

# rename columns to remove '_interval' suffix for clarity 
daily_agg = daily_agg.rename(columns={f'{col}_interval': col for col in rate_columns})

display(daily_agg.head(10))

# list of unique voyage_id
unique_voyage_ids = list(daily_agg['voyage_id'].unique())
print(unique_voyage_ids)

selected_voyage_id = 'voyage_13'

df_voyage = daily_agg[daily_agg['voyage_id'] == selected_voyage_id].copy()

display(df_voyage.head(10))

fuel_components = [
    'fuel_calm_water',
    'abs_contrib_wind_speed',
    'abs_contrib_wave_height',
    'abs_contrib_current_speed',
    'abs_contrib_draft_avg',
    'abs_contrib_fuel_specific_energy',
    'abs_fouling'
] 
df_voyage['date'] = pd.to_datetime(df_voyage['date']) 
df_voyage.set_index('date', inplace=True)

from plotly.subplots import make_subplots
import plotly.graph_objects as go

# Define colors for consistency
component_colors = {
    'fuel_calm_water': '#4c78a8',
    'abs_contrib_wind_speed': '#f58518',
    'abs_contrib_wave_height': '#54a24b',
    'abs_contrib_current_speed': '#b79a20',
    'abs_contrib_draft_avg': '#e45756',
    'abs_contrib_fuel_specific_energy': '#72b7b2',
    'abs_fouling': '#9d7de5'
}

# Extract draft_mode and avg_draft_avg for the selected voyage
draft_info = avg_draft_per_voyage.loc[avg_draft_per_voyage["voyage_id"] == selected_voyage_id]

if not draft_info.empty:
    draft_mode = draft_info.iloc[0]["draft_mode"]
    draft_ref_value = (ballast_draft if draft_mode == "ballast" else laden_draft)
    draft_label = ("Draft<br>"f"<span style='font-size:11px; color:gray'>(ref: {draft_ref_value})</span>")
else:
    draft_label = "Draft"

# Reference lcv 
lcv_label = ("Fuel Energy Density <br>"f"<span style='font-size:11px; color:gray'>(ref: 41.6 MJ/kg)</span>")

# Get benchmark info
model_url = f"https://api.toqua.ai/ships/{IMO_NUMBER}/models/latest/metadata"
model_response = requests.get(model_url, headers=headers)
benchmark_label = "Hull Degradation"

if model_response.ok:
    model_info = model_response.json()
    periods = model_info.get("periods", [])
    bm = next((p for p in periods if p.get("type") == "benchmark"), None)
    
    if bm and bm.get("start_date") and bm.get("end_date"):
        start = bm["start_date"][:10]
        end = bm["end_date"][:10]
        benchmark_label = ("Hull Degradation<br>"f"<span style='font-size:11px; color:gray'>(ref: {start} → {end})</span>")
else:
    raise Exception(f"❌ API Error {model_response.status_code}: {model_response.text}")

# Set final legend labels
legend_labels = {
    'fuel_calm_water': 'Calm Water',
    'abs_contrib_wind_speed': 'Wind',
    'abs_contrib_wave_height': 'Waves',
    'abs_contrib_current_speed': 'Currents',
    'abs_contrib_draft_avg': draft_label,
    'abs_contrib_fuel_specific_energy': lcv_label,
    'abs_fouling': benchmark_label
}

component_totals = df_voyage[fuel_components].sum()

# Ensure calm water is first
calm_water = ['fuel_calm_water']
weather_order = ['abs_contrib_wind_speed', 'abs_contrib_wave_height', 'abs_contrib_current_speed']

# Identify zero and non-zero components
zero_components = component_totals[component_totals == 0].index.tolist()
non_zero_components = [c for c in component_totals.index if c not in zero_components]

# Extract non-zero components by categories
non_zero_calm = [c for c in calm_water if c in non_zero_components]
non_zero_weather = [c for c in weather_order if c in non_zero_components]
non_zero_others = [c for c in non_zero_components if c not in non_zero_calm + non_zero_weather]

# Final order: Calm Water → Weather → Other non-zero → Zero components
ordered_components = (
    non_zero_calm +
    non_zero_weather +
    non_zero_others +
    [c for c in zero_components if c not in non_zero_calm + non_zero_weather + non_zero_others]
)

total_sum = component_totals.sum()

weather_components = ['abs_contrib_wind_speed', 'abs_contrib_wave_height', 'abs_contrib_current_speed']
weather_total = component_totals.loc[component_totals.index.intersection(weather_components)].sum()
weather_pct = (weather_total / total_sum) * 100 if total_sum else 0

fig = make_subplots(
    rows=1, cols=1,
    specs=[[{"type": "bar"}]]
)

# Plot: Horizontal breakdown
y_labels = []
y_vals = []

for i, col in enumerate(component_totals.index):
    label = legend_labels.get(col, col)
    color = component_colors.get(col, '#999999')
    value = component_totals[col]
    pct = (value / total_sum) * 100
    text = f"{value:.1f} mt<br>({pct:.1f}%)"

    # Styled label with exact color
    styled_label = label  # plain default color
    y_labels.append(styled_label)
    y_vals.append(i)
    
    fig.add_trace(go.Bar(
        x=[value],
        y=[i],
        orientation='h',
        marker_color=color,
        text=None,  # we'll handle text ourselves
        hoverinfo='skip',
        showlegend=False,
        cliponaxis=False
    ))

    fig.add_annotation(
        x=max(value, 0) + 5,  # offset to the right of the bar end
        y=i,
        text=text,
        showarrow=False,
        font=dict(size=11, color="black"),
        xanchor='left',
        yanchor='middle'
    )

    annotation_x = max(value, 0) + 5  # ensures even 0 or negative bars show label on the right

    fig.add_annotation(
        x=annotation_x,
        y=i,
        text=text,
        showarrow=False,
        font=dict(size=11, color="black"),
        xanchor='left',
        yanchor='middle'
    )
    
weather_indices = [i for i, col in enumerate(component_totals.index) if col in weather_components]
if weather_indices:
    y_top = max(weather_indices) +0.5
    y_bottom = min(weather_indices) -0.5
    y_mid = (y_top + y_bottom) / 2

# Layout and styling
total_days = df_voyage.index.nunique()
total_fuel = df_voyage[fuel_components].sum(axis=1).sum()
avg_fuel_per_day = total_fuel / total_days if total_days else 0
avg_speed = df_voyage['sog'].mean()  

fig.update_layout(
    barmode='relative',
    height=500,
    width=1000,
    template='plotly_white',
    title=dict(
        text=(
            f'Voyage-Leg Fuel Breakdown<br>'
            f'<span style="font-size:12px; color:gray">'
            f'Voyage Leg ID: <b>{selected_voyage_id}</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
            f'Days at Sea: <b>{total_days}</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
            f'Total Fuel Consumption: <b>{total_fuel:.1f} metric tons</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
            f'Average ME Speed-Cons: <b>{avg_fuel_per_day:.1f} mt/day</b> at <b>{avg_speed:.1f} knots</b>'
            f'</span>'
        ),
        x=0.5,
        xanchor='center'
    ),
    xaxis_title='Total Contribution (metric tons)',
    
    yaxis=dict(tickmode='array',tickvals=y_vals,ticktext=y_labels,automargin=True, autorange ='reversed'),
    margin=dict(t=100, l=180, r=30, b=30),
    legend=dict(orientation='v',yanchor='top',y=1,xanchor='left',x=-0.15)
)

# Positioning logic 
weather_bar_max = max([component_totals.get(c, 0) for c in weather_components])
x_offset = weather_bar_max + 120  # further to the right
x_text = x_offset + 5

# Draw brace-like accolade using path
cap_length = 25  # horizontal line length
line_color = "gray"
line_width = 2

# Vertical line
fig.add_shape(
    type="line",
    xref="x", yref="y",
    x0=x_offset, x1=x_offset,
    y0=y_bottom, y1=y_top,
    line=dict(color=line_color, width=line_width)
)

# Top cap
fig.add_shape(
    type="line",
    xref="x", yref="y",
    x0=x_offset, x1=x_offset - cap_length,
    y0=y_top, y1=y_top,
    line=dict(color=line_color, width=line_width)
)

# Bottom cap
fig.add_shape(
    type="line",
    xref="x", yref="y",
    x0=x_offset, x1=x_offset - cap_length,
    y0=y_bottom, y1=y_bottom,
    line=dict(color=line_color, width=line_width)
)

# Add nicely formatted label 
weather_text = f"Total Weather Margin: {weather_pct:.1f}%"
fig.add_annotation(
    x=x_text,
    y=y_mid,
    xref='x',
    yref='y',
    text=weather_text,
    showarrow=False,
    align='left',
    font=dict(size=12, color='black'),
    xanchor='left',
    yanchor='middle',
    bordercolor='rgba(0,0,0,0.05)',
    borderwidth=0
)

fig.show()

# advanced visual 

from plotly.subplots import make_subplots
import plotly.graph_objects as go

# --- Colors for consistency ---
component_colors = {
    'fuel_calm_water': '#4c78a8',
    'abs_contrib_wind_speed': '#f58518',
    'abs_contrib_wave_height': '#54a24b',
    'abs_contrib_current_speed': '#b79a20',
    'abs_contrib_draft_avg': '#e45756',
    'abs_contrib_fuel_specific_energy': '#72b7b2',
    'abs_fouling': '#9d7de5'
}

# --- Legend labels with references ---
draft_info = avg_draft_per_voyage.loc[avg_draft_per_voyage["voyage_id"] == selected_voyage_id]

if not draft_info.empty:
    draft_mode = draft_info.iloc[0]["draft_mode"]
    draft_ref_value = (
        ballast_draft
        if draft_mode == "ballast"
        else round(draft_info.iloc[0]["avg_draft_avg"], 1)
    )

    draft_label = (
        "Draft<br>"
        f"<span style='font-size:11px; color:gray'>(ref: {draft_ref_value})</span>"
    )
else:
    draft_label = "Draft"


ballast_draft = ship_info.get("ballast_draft")
lcv_label = "Fuel Energy Density <br><span style='font-size:11px; color:gray'>(ref: 41.6 MJ/kg)</span>"

# Get benchmark info
model_url = f"https://api.toqua.ai/ships/{IMO_NUMBER}/models/latest/metadata"
model_response = requests.get(model_url, headers=headers)
benchmark_label = "Hull Degradation"

if model_response.ok:
    model_info = model_response.json()
    periods = model_info.get("periods", [])
    bm = next((p for p in periods if p.get("type") == "benchmark"), None)
    
    if bm and bm.get("start_date") and bm.get("end_date"):
        start = bm["start_date"][:10]
        end = bm["end_date"][:10]
        benchmark_label = ("Hull Degradation<br>"
                           f"<span style='font-size:11px; color:gray'>(ref: {start} → {end})</span>"
        )
else:
    raise Exception(f"❌ API Error {model_response.status_code}: {model_response.text}")

legend_labels = {
    'fuel_calm_water': 'Calm Water',
    'abs_contrib_wind_speed': 'Wind',
    'abs_contrib_wave_height': 'Waves',
    'abs_contrib_current_speed': 'Currents',
    'abs_contrib_draft_avg': draft_label,
    'abs_contrib_fuel_specific_energy': lcv_label,
    'abs_fouling': benchmark_label
}

fig = make_subplots(
    rows=1, cols=1,
    subplot_titles=("Fuel Consumption Over Time",),
    specs=[[{"type": "bar"}]]
)
plot_order = fuel_components[::-1]
base_component = 'fuel_calm_water'
adjustment_components = [col for col in plot_order if col != base_component]
stacked_columns = [base_component] + adjustment_components
df_voyage['total_visible_bar'] = df_voyage[stacked_columns].sum(axis=1)

# -- Plot base (calm water) --
fig.add_trace(go.Bar(
    x=df_voyage.index,
    y=df_voyage[base_component],
    name=legend_labels.get(base_component, base_component),
    marker_color=component_colors.get(base_component, '#999999'),
    hoverinfo='x+y+name'
), row=1, col=1)

# -- Plot adjustment components stacked --
for col in adjustment_components:
    fig.add_trace(go.Bar(
        x=df_voyage.index,
        y=df_voyage[col],
        name=legend_labels.get(col, col),
        marker_color=component_colors.get(col, '#999999'),
        hoverinfo='x+y+name'
    ), row=1, col=1)

# -- Total fuel dashed line --
fig.add_trace(go.Scatter(
    x=df_voyage.index,
    y=df_voyage['total_visible_bar'],
    mode='lines+markers',
    name='Total Fuel',
    line=dict(color='black', width=2, dash='dash'),
    marker=dict(size=6),
    hoverinfo='x+y'
), row=1, col=1)

df_voyage['bar_top'] = (df_voyage[base_component] + df_voyage[adjustment_components].clip(lower=0).sum(axis=1))

# -- Text annotations above bars --
fig.add_trace(go.Scatter(
    x=df_voyage.index,
    y=df_voyage['bar_top'] + 0.5,
    mode='text',
    text=[f"{val:.1f} mt" for val in df_voyage['total_visible_bar']],
    textposition='top center',
    textfont=dict(size=11, color='black', family='Arial Black'),
    showlegend=False,
    hoverinfo='skip'
), row=1, col=1)

# -- Layout --
avg_fuel_per_day = total_fuel / total_days if total_days else 0
avg_speed = df_voyage['sog'].mean()  
fig.update_layout(
    barmode='relative',
    height=500,
    width=1200,
    template='plotly_white',
    title=dict(
        text=(
            f'Voyage-leg Fuel Breakdown<br>'
            f'<span style="font-size:12px; color:gray">'
            f'Voyage Leg ID: <b>{selected_voyage_id}</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
            f'Days at Sea: <b>{total_days}</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
            f'Total Fuel Consumption: <b>{total_fuel:.1f} metric tons</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
            f'Average Speed-Cons: <b>{avg_fuel_per_day:.1f} mt/day</b> at <b>{avg_speed:.1f} knots</b>'
            f'</span>'),
        x=0.5,
        xanchor='center'
    ),
    legend_title=None,
    legend=dict(orientation='h',yanchor='bottom',y=-0.45,xanchor='center',x=0.5,font=dict(size=12),title=None),
    xaxis_title='Date',
    yaxis_title='Fuel Consumption (metric_tons/day)',
    margin=dict(t=100, l=30, r=30, b=20)
)

fig.show()

from plotly.subplots import make_subplots
import plotly.graph_objects as go

# -------------------------------
# Define colors for consistency
# -------------------------------
component_colors = {
    'fuel_calm_water': '#4c78a8',
    'abs_contrib_wind_speed': '#f58518',
    'abs_contrib_wave_height': '#54a24b',
    'abs_contrib_current_speed': '#b79a20',
    'abs_contrib_draft_avg': '#e45756',
    'abs_contrib_fuel_specific_energy': '#72b7b2',
    'abs_fouling': '#9d7de5'
}

# Reference draft
draft_info = avg_draft_per_voyage.loc[avg_draft_per_voyage["voyage_id"] == selected_voyage_id]

if not draft_info.empty:
    draft_mode = draft_info.iloc[0]["draft_mode"]
    draft_ref_value = (
        ballast_draft
        if draft_mode == "ballast"
        else round(draft_info.iloc[0]["avg_draft_avg"], 1)
    )

    draft_label = (
        "Draft<br>"
        f"<span style='font-size:11px; color:gray'>(ref: {draft_ref_value})</span>"
    )
else:
    draft_label = "Draft"


# Get benchmark info
model_url = f"https://api.toqua.ai/ships/{IMO_NUMBER}/models/latest/metadata"
model_response = requests.get(model_url, headers=headers)
benchmark_label = "Hull Degradation"

if model_response.ok:
    model_info = model_response.json()
    periods = model_info.get("periods", [])
    bm = next((p for p in periods if p.get("type") == "benchmark"), None)
    
    if bm and bm.get("start_date") and bm.get("end_date"):
        start = bm["start_date"][:10]
        end = bm["end_date"][:10]
        benchmark_label = f"Hull Degradation (ref: {start} → {end})"
else:
    raise Exception(f"❌ API Error {model_response.status_code}: {model_response.text}")

# reference lcv
lcv_label = "Fuel Energy Density <br><span style='font-size:11px; color:gray'>(ref: 41.6 MJ/kg)</span>"


# Set final legend labels
legend_labels = {
    'fuel_calm_water': 'Calm Water',
    'abs_contrib_wind_speed': 'Wind',
    'abs_contrib_wave_height': 'Waves',
    'abs_contrib_current_speed': 'Current',
    'abs_contrib_draft_avg': draft_label,
    'abs_contrib_fuel_specific_energy': lcv_label,
    'abs_fouling': benchmark_label
}

plot_order = fuel_components[::-1]  # bottom to top stack

# -------------------------------
# Split data into + and - parts
# -------------------------------
df_pos = df_voyage[plot_order].clip(lower=0)
df_neg = df_voyage[plot_order].clip(upper=0)
component_totals = df_voyage[fuel_components].sum().sort_values()

# -------------------------------
# Create subplot layout
# -------------------------------
fig = make_subplots(
    rows=1, cols=2,
    column_widths=[0.55, 0.45],
    subplot_titles=("Fuel Consumption Over Time", "Contribution by Factor"),
    specs=[[{"type": "bar"}, {"type": "bar"}]]
)

# -------------------------------
# Left plot: Stacked bar over time
# -------------------------------
base_component = 'fuel_calm_water'
adjustment_components = [col for col in plot_order if col != base_component]
stacked_columns = [base_component] + adjustment_components
df_voyage['total_visible_bar'] = df_voyage[stacked_columns].sum(axis=1)

# Plot calm water baseline
fig.add_trace(go.Bar(
    x=df_voyage.index,
    y=df_voyage[base_component],
    name=legend_labels.get(base_component, base_component),
    marker_color=component_colors.get(base_component, '#999999'),
    hoverinfo='x+y+name'
), row=1, col=1)

# Plot all adjustment components stacked on top
for col in adjustment_components:
    fig.add_trace(go.Bar(
        x=df_voyage.index,
        y=df_voyage[col],
        name=legend_labels.get(col, col),
        marker_color=component_colors.get(col, '#999999'),
        hoverinfo='x+y+name'
    ), row=1, col=1)

# Compute total bar height for each day
df_voyage['bar_top'] = (df_voyage[base_component] + df_voyage[adjustment_components].clip(lower=0).sum(axis=1))

# Add dashed black line for total fuel
fig.add_trace(go.Scatter(
    x=df_voyage.index,
    y=df_voyage['total_visible_bar'],
    mode='lines+markers',
    name='Total Fuel',
    line=dict(color='black', width=2, dash='dash'),
    marker=dict(size=6),
    hoverinfo='x+y'
), row=1, col=1)

# Add total fuel value as text just above the bar
fig.add_trace(go.Scatter(
    x=df_voyage.index,
    y=df_voyage['bar_top'] + 0.5,  # minimal lift for readability
    mode='text',
    text=[f"{val:.1f} mt" for val in df_voyage['total_visible_bar']],
    textposition='top center',
    textfont=dict(
        size=11,
        color='black',
        family='Arial Black'
    ),
    showlegend=False,
    hoverinfo='skip'
), row=1, col=1)

# -------------------------------
# Right plot: Horizontal breakdown with ordering + annotation
# -------------------------------
component_totals = df_voyage[fuel_components].sum()

# Reorder: Calm Water → Weather → Other → Zero
calm_water = ['fuel_calm_water']
weather_order = ['abs_contrib_wind_speed', 'abs_contrib_wave_height', 'abs_contrib_current_speed']
zero_components = component_totals[component_totals == 0].index.tolist()
non_zero_components = [c for c in component_totals.index if c not in zero_components]
non_zero_calm = [c for c in calm_water if c in non_zero_components]
non_zero_weather = [c for c in weather_order if c in non_zero_components]
non_zero_others = [c for c in non_zero_components if c not in non_zero_calm + non_zero_weather]

ordered_components = (
    non_zero_calm +
    non_zero_weather +
    non_zero_others +
    [c for c in zero_components if c not in non_zero_calm + non_zero_weather + non_zero_others]
)

component_totals = component_totals.loc[ordered_components]
total_sum = component_totals.sum()

# Build bar + labels
y_labels = [legend_labels.get(col, col) for col in ordered_components]
y_vals = list(range(len(ordered_components)))

for i, col in enumerate(ordered_components):
    value = component_totals[col]
    pct = (value / total_sum) * 100 if total_sum else 0
    text = f"{value:.1f} mt<br>({pct:.1f}%)"

    fig.add_trace(go.Bar(
        x=[value],
        y=[i],
        orientation='h',
        marker_color=component_colors.get(col, '#999999'),
        text=None,
        hoverinfo='skip',
        showlegend=False,
        cliponaxis=False
    ), row=1, col=2)

    fig.add_annotation(
        x=max(value, 0) + 5,
        y=i,
        text=text,
        showarrow=False,
        font=dict(size=11, color="black"),
        xref='x2',
        yref='y2',
        xanchor='left',
        yanchor='middle',
        row=1, col=2
    )

# Add weather group brace
weather_components = weather_order
weather_indices = [i for i, col in enumerate(ordered_components) if col in weather_components]
if weather_indices:
    y_top = max(weather_indices) + 0.5
    y_bottom = min(weather_indices) - 0.5
    y_mid = (y_top + y_bottom) / 2
    weather_bar_max = max([component_totals.get(c, 0) for c in weather_components])
    x_offset = weather_bar_max + 120
    x_text = x_offset + 5

    cap_length = 25
    line_color = "gray"
    line_width = 2
    weather_pct = (component_totals[weather_components].sum() / total_sum) * 100 if total_sum else 0

    fig.add_shape(type="line", xref="x2", yref="y2",
                  x0=x_offset, x1=x_offset,
                  y0=y_bottom, y1=y_top,
                  line=dict(color=line_color, width=line_width),
                  row=1, col=2)

    fig.add_shape(type="line", xref="x2", yref="y2",
                  x0=x_offset, x1=x_offset - cap_length,
                  y0=y_top, y1=y_top,
                  line=dict(color=line_color, width=line_width),
                  row=1, col=2)

    fig.add_shape(type="line", xref="x2", yref="y2",
                  x0=x_offset, x1=x_offset - cap_length,
                  y0=y_bottom, y1=y_bottom,
                  line=dict(color=line_color, width=line_width),
                  row=1, col=2)

    fig.add_annotation(
        x=x_text,
        y=y_mid,
        xref='x2',
        yref='y2',
        text=f"Total Weather Margin: {weather_pct:.1f}%",
        showarrow=False,
        align='left',
        font=dict(size=12, color='black'),
        xanchor='left',
        yanchor='middle',
        row=1, col=2
    )

# Fix axis to reverse so Calm Water appears first
fig.update_yaxes(
    tickmode='array',
    tickvals=y_vals,
    ticktext=y_labels,
    automargin=True,
    autorange='reversed',
    row=1, col=2
)

# -------------------------------
# Layout and styling
# -------------------------------
total_days = df_voyage.index.nunique()
total_fuel = df_voyage['total_visible_bar'].sum()

fig.update_layout(
    barmode='relative',
    height=500,
    width=1650,
    template='plotly_white',
    title= dict(
                text=f'Voyage-Leg Fuel Contribution Breakdown Over Time<br>' 
                     f'<span style="font-size:12px; color:gray">'
                     f'Voyage Leg ID: <b>{selected_voyage_id}</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
                     f'Days at Sea: <b>{total_days}</b> &nbsp;&nbsp;|&nbsp;&nbsp; '
                     f'Total Fuel Consumption: <b>{total_fuel:.1f} metric tons</b>'
                     f'</span>',
                x=0.5,
                xanchor='center'
    ),
    legend_title= None,
    legend=dict(orientation='h',yanchor='bottom', y=-0.45, xanchor='center', x=0.5),
    xaxis_title='Date',
    yaxis_title='Fuel Consumption (metric_tons/day)',
    xaxis2=dict(title='Total Contribution (metric_tons)', showgrid=True, zeroline=True, tickformat=".0f"),
    yaxis2=dict(automargin=True, showticklabels=False),
    margin=dict(t=100, l=30, r=30, b=10)
)

fig.show()