from src.data.data_loader import DataLoader
from src.data.data_preprocessing import DataPreprocessor
from src.models.train import ModelTrainer
from src.models.evaluate import ModelEvaluator

# Step 1: Load data
loader = DataLoader()
df = loader.load_csv("data/raw/car_data.csv")
print(f"Loaded {len(df)} records")

# Step 2: Validate and clean
is_valid, issues = loader.validate_data(df)
if not is_valid:
    print(f"Data issues found: {issues}")

preprocessor = DataPreprocessor()
df_clean = preprocessor.clean_data(df)

# Step 3: Feature engineering
df_features = preprocessor.create_features(df_clean)
X_train, y_train = preprocessor.prepare_features(df_features, fit=True)

# Step 4: Train models
trainer = ModelTrainer()
trainer.train_all_models(X_train, y_train)

# Step 5: Evaluate and select best
best_name, best_model = trainer.select_best_model()
print(f"Best model: {best_name}")

# Step 6: Save for production
trainer.save_models("models/")

from src.models.predict import ModelPredictor

# Initialize predictor
predictor = ModelPredictor(
    model_path="models/best_model.pkl",
    preprocessor_path="models/preprocessor.pkl"
)

# Single car prediction
car_details = {
    'year': 2018,
    'km_driven': 50000,
    'fuel': 'Petrol',
    'seller_type': 'Individual',
    'transmission': 'Manual',
    'owner': 'First Owner',
    'mileage': 18.5,
    'engine': 1200,
    'max_power': 85,
    'seats': 5
}

predicted_price = predictor.predict_single(**car_details)
print(f"💰 Predicted Price: ₹{predicted_price:,.2f}")

# Batch predictions
import pandas as pd
new_cars = pd.read_csv("data/new_inventory.csv")
predictions = predictor.predict(new_cars)
new_cars['predicted_price'] = predictions

from src.models.train import ModelTrainer
from sklearn.ensemble import GradientBoostingRegressor

# Initialize trainer
trainer = ModelTrainer()

# Add custom model
custom_model = GradientBoostingRegressor(
    n_estimators=200,
    learning_rate=0.1,
    max_depth=5
)
trainer.add_model("GradientBoosting", custom_model)

# Train all models
trainer.train_all_models(X_train, y_train)

# Compare performance
results = trainer.get_model_results()
print(results)

from src.models.train import ModelTrainer

trainer = ModelTrainer()
trainer.tune_hyperparameters(
    X_train, y_train,
    model_name='xgboost',
    param_grid={
        'n_estimators': [100, 200, 300],
        'max_depth': [3, 5, 7],
        'learning_rate': [0.01, 0.1, 0.3]
    },
    cv=5
)

from src.models.evaluate import ModelEvaluator

evaluator = ModelEvaluator()
metrics = evaluator.evaluate(model, X_test, y_test)

print(f"""
📈 Model Performance:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  RMSE:  ₹{metrics['rmse']:,.2f}
  MAE:   ₹{metrics['mae']:,.2f}
  R²:    {metrics['r2']:.4f}
  MAPE:  {metrics['mape']:.2f}%
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
""")