import sys
import time
import warnings
import logging
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
from sklearn.model_selection import train_test_split

from breeze_ml.data import read_data
from breeze_ml.metrics import write_training_results, print_elapsed_time
from breeze_ml.export import BreezeExportWrapper
from breeze_ml.training import train_network

# --- Setup & Data Loading ---
TRAIN_DATA, TEST_DATA, ONNX_DESTINATION, TRAINING_INFORMATION_FILE = sys.argv[-4:]

xs, ys, wls = read_data(TRAIN_DATA)
x_test, y_test, _ = read_data(TEST_DATA)
if len(xs) == 0: raise FileNotFoundError(f"Failed to load data: {TRAIN_DATA}")

original_unique_labels = np.unique(ys).flatten().tolist()
class_to_idx = {val: idx for idx, val in enumerate(original_unique_labels)}
ys_mapped, y_test_mapped = np.array([class_to_idx[y] for y in ys], dtype=np.int64), np.array([class_to_idx[y] for y in y_test], dtype=np.int64)

x_train, x_val, y_train, y_val = train_test_split(xs, ys_mapped, test_size=0.15, stratify=ys_mapped, random_state=42)

train_loader = DataLoader(TensorDataset(torch.tensor(x_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.int64)), batch_size=32, shuffle=True)
val_loader = DataLoader(TensorDataset(torch.tensor(x_val, dtype=torch.float32), torch.tensor(y_val, dtype=torch.int64)), batch_size=32, shuffle=False)

# --- Model Definition ---
class HSIClassifier(nn.Module):
    def __init__(self, input_dim, num_classes):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 32), nn.Tanh(), nn.BatchNorm1d(32),
            nn.Linear(32, 32), nn.Mish(), nn.Dropout(0.1),
            nn.Linear(32, 32), nn.Tanh(), nn.Linear(32, num_classes)
        )
    def forward(self, x): return torch.softmax(self.net(x), dim=1)

model = HSIClassifier(wls, len(original_unique_labels))

# --- Train ---
optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=5e-4)
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.96)
criterion = nn.CrossEntropyLoss()

start_time = time.time()
# The entire training loop is now a single line!
model = train_network(model, train_loader, val_loader, criterion, optimizer, scheduler, epochs=150)
end_time = time.time()

# --- Evaluate & Export ---
model.eval()
with torch.no_grad():
    score_training_data = (model(torch.tensor(xs, dtype=torch.float32)).argmax(dim=1).numpy() == ys_mapped).mean()
    test_accuracy = (model(torch.tensor(x_test, dtype=torch.float32)).argmax(dim=1).numpy() == y_test_mapped).mean()

export_model = BreezeExportWrapper(model, original_unique_labels).eval()

warnings.filterwarnings("ignore", category=UserWarning, module="torch.onnx")
logging.getLogger("torch.onnx").setLevel(logging.ERROR)

torch.onnx.export(
    export_model, (torch.randn(1, wls, dtype=torch.float32),), ONNX_DESTINATION,
    input_names=["Features"], output_names=["Score.output", "PredictedLabel.output"],
    dynamic_axes={"Features": {0: "batch_size"}, "Score.output": {0: "batch_size"}, "PredictedLabel.output": {0: "batch_size"}},
    opset_version=18
)

print_elapsed_time(end_time - start_time)
write_training_results(score_training_data, test_accuracy, end_time - start_time, None, "Neural Network", TRAINING_INFORMATION_FILE)