from vpp import VirtualPowerPlant
from vpp.resources import Battery, Solar, WindTurbine
from vpp.optimization import LinearProgrammingStrategy
from vpp.config import VPPConfig

# Initialize VPP with LP strategy
vpp = VirtualPowerPlant(
    config=VPPConfig(name="Production VPP"),
    strategy=LinearProgrammingStrategy()
)

# Add resources
battery = Battery(
    capacity=2000,      # 2 MWh
    current_charge=1500, # 75% charged
    max_power=500,      # 500 kW
    nominal_voltage=400  # 400V
)

solar = Solar(
    peak_power=1000,    # 1 MW
    panel_area=5000,    # 5000 m²
    efficiency=0.22     # 22% efficiency
)

wind = WindTurbine(
    rated_power=2000,   # 2 MW
    rotor_diameter=70,  # 70m rotor
    hub_height=80,      # 80m height
    cut_in_speed=3.0,   # Min wind speed
    cut_out_speed=25.0, # Max wind speed
    rated_speed=12.0    # Rated wind speed
)

# Add resources and optimize
vpp.add_resource(battery)
vpp.add_resource(solar)
vpp.add_resource(wind)

result = vpp.optimize_dispatch(target_power=3000)  # Target 3 MW
print(f"Optimization success: {result.success}")
print(f"Power allocation: {result.resource_allocation}")

from vpp import VirtualPowerPlant
from vpp.simulation import Simulator, SimulationConfig
from vpp.analysis import PerformanceAnalyzer
from vpp.visualization import PowerPlotter, StrategyPlotter
from datetime import datetime, timedelta

# Configure simulation
config = SimulationConfig(
    start_time=datetime.now(),
    end_time=datetime.now() + timedelta(days=7),
    time_step=timedelta(minutes=15),
    include_weather=True,
    include_market=True
)

# Create simulator
simulator = Simulator(config, vpp.resources, vpp.strategy)

# Run simulation with varying target power
def target_power_func(timestamp: datetime) -> float:
    hour = timestamp.hour
    if 9 <= hour <= 20:  # Peak hours
        return 3000
    return 1500

metrics = simulator.run(target_power_func)

# Analyze results
analyzer = PerformanceAnalyzer()
system_perf = analyzer.analyze_system(
    simulator.states,
    simulator.optimization_results
)

# Visualize results
plotter = PowerPlotter()
power_fig = plotter.plot_power_output(simulator.states)
power_fig.savefig('power_output.png')

strategy_plotter = StrategyPlotter()
comparison_fig = strategy_plotter.plot_strategy_comparison({
    'LP': simulator.optimization_results
})
comparison_fig.savefig('strategy_comparison.png')

from vpp.optimization import OptimizationStrategy, OptimizationResult
from typing import List

class CustomStrategy(OptimizationStrategy):
    def optimize(
        self,
        resources: List[EnergyResource],
        target_power: float
    ) -> OptimizationResult:
        # Your custom optimization logic here
        allocations = {}
        for resource in resources:
            # Example: Simple proportional allocation
            power = (resource.rated_power / sum(r.rated_power for r in resources)) * target_power
            allocations[resource.__class__.__name__] = min(power, resource.rated_power)
        
        return OptimizationResult(
            success=True,
            target_power=target_power,
            actual_power=sum(allocations.values()),
            resource_allocation=allocations
        )

# Use custom strategy
vpp = VirtualPowerPlant(
    config=VPPConfig(name="Custom VPP"),
    strategy=CustomStrategy()
)