src/geometry/plot_generator.py

"""
Plot Generator - Industrial Plot Layout Generation
Generates optimal plot layouts within buildable area
"""
import numpy as np
from shapely.geometry import Polygon, MultiPolygon, box, LineString
from shapely.ops import unary_union
from shapely.affinity import rotate, translate
from typing import List, Tuple, Optional, Dict
import logging
import yaml
from pathlib import Path
import uuid

from src.models.domain import SiteBoundary, Plot, PlotType, RoadNetwork

logger = logging.getLogger(__name__)


class PlotGenerator:
    """
    Industrial plot generator
    
    Responsibilities:
    - Generate plot subdivisions within buildable area
    - Optimize plot orientation for efficiency
    - Ensure road access for all plots
    - Handle varied plot sizes
    """
    
    def __init__(self, regulations_path: str = "config/regulations.yaml"):
        """
        Initialize plot generator
        
        Args:
            regulations_path: Path to regulations YAML
        """
        self.regulations_path = Path(regulations_path)
        self.regulations = self._load_regulations()
        self.logger = logging.getLogger(__name__)
        
        # Load plot requirements
        plot_config = self.regulations.get('plot', {})
        self.min_area = plot_config.get('minimum_area_sqm', 1000)
        self.max_area = plot_config.get('maximum_area_sqm', 50000)
        self.min_width = plot_config.get('minimum_width_m', 20)
        self.min_frontage = plot_config.get('minimum_frontage_m', 15)
    
    def _load_regulations(self) -> dict:
        """Load regulations from YAML"""
        if not self.regulations_path.exists():
            return {}
        with open(self.regulations_path, 'r', encoding='utf-8') as f:
            return yaml.safe_load(f)
    
    def generate_grid_plots(
        self,
        site: SiteBoundary,
        road_network: RoadNetwork,
        plot_width: float = 100,
        plot_depth: float = 100,
        road_setback: float = 5
    ) -> List[Plot]:
        """
        Generate plots in a regular grid pattern
        
        Args:
            site: Site boundary
            road_network: Road network for access checking
            plot_width: Standard plot width
            plot_depth: Standard plot depth
            road_setback: Setback from roads
            
        Returns:
            List of Plot objects
        """
        self.logger.info(f"Generating grid plots: {plot_width}m x {plot_depth}m")
        
        # Get buildable area (after boundary setback)
        setback = self.regulations.get('setbacks', {}).get('boundary_minimum', 50)
        buildable = site.geometry.buffer(-setback)
        
        if buildable.is_empty:
            self.logger.warning("No buildable area after setback")
            return []
        
        # Get road polygons to avoid
        road_polygons = self._get_road_polygons(road_network)
        if road_polygons:
            road_union = unary_union(road_polygons)
            buildable = buildable.difference(road_union.buffer(road_setback))
        
        if buildable.is_empty:
            self.logger.warning("No buildable area after road subtraction")
            return []
        
        # Get bounds
        minx, miny, maxx, maxy = buildable.bounds
        
        plots = []
        plot_id = 0
        
        # Generate grid of plots
        y = miny
        while y + plot_depth <= maxy:
            x = minx
            while x + plot_width <= maxx:
                plot_geom = box(x, y, x + plot_width, y + plot_depth)
                
                # Check if plot fits in buildable area
                if buildable.contains(plot_geom):
                    # Check if plot area meets minimum
                    if plot_geom.area >= self.min_area:
                        plot = Plot(
                            id=f"plot_{plot_id:03d}",
                            geometry=plot_geom,
                            area_sqm=plot_geom.area,
                            type=PlotType.INDUSTRIAL,
                            width_m=plot_width,
                            depth_m=plot_depth,
                            frontage_m=plot_width,
                            has_road_access=self._check_road_access(plot_geom, road_network),
                            orientation_degrees=0
                        )
                        plots.append(plot)
                        plot_id += 1
                elif buildable.intersects(plot_geom):
                    # Try to fit partial plot
                    intersection = buildable.intersection(plot_geom)
                    if isinstance(intersection, Polygon) and intersection.area >= self.min_area:
                        plot = Plot(
                            id=f"plot_{plot_id:03d}",
                            geometry=intersection,
                            area_sqm=intersection.area,
                            type=PlotType.INDUSTRIAL,
                            width_m=self._estimate_width(intersection),
                            depth_m=self._estimate_depth(intersection),
                            frontage_m=self._estimate_width(intersection),
                            has_road_access=self._check_road_access(intersection, road_network),
                            orientation_degrees=0
                        )
                        plots.append(plot)
                        plot_id += 1
                
                x += plot_width
            y += plot_depth
        
        self.logger.info(f"Generated {len(plots)} grid plots")
        return plots
    
    def generate_varied_plots(
        self,
        site: SiteBoundary,
        road_network: RoadNetwork,
        size_distribution: Dict[str, float] = None
    ) -> List[Plot]:
        """
        Generate plots with varied sizes
        
        Args:
            site: Site boundary
            road_network: Road network for access checking
            size_distribution: Dict of size:percentage, e.g., {'small': 0.3, 'medium': 0.5, 'large': 0.2}
            
        Returns:
            List of Plot objects
        """
        if size_distribution is None:
            size_distribution = {
                'small': 0.3,   # 1000-2000 sqm
                'medium': 0.5,  # 2000-5000 sqm
                'large': 0.2    # 5000-10000 sqm
            }
        
        size_specs = {
            'small': {'width': 40, 'depth': 50},
            'medium': {'width': 70, 'depth': 70},
            'large': {'width': 100, 'depth': 100}
        }
        
        self.logger.info("Generating varied size plots")
        
        setback = self.regulations.get('setbacks', {}).get('boundary_minimum', 50)
        buildable = site.geometry.buffer(-setback)
        
        road_polygons = self._get_road_polygons(road_network)
        if road_polygons:
            road_union = unary_union(road_polygons)
            buildable = buildable.difference(road_union.buffer(5))
        
        if buildable.is_empty:
            return []
        
        plots = []
        remaining_area = buildable
        plot_id = 0
        
        # Target area for each size category
        total_buildable = buildable.area
        target_areas = {
            size: total_buildable * pct for size, pct in size_distribution.items()
        }
        
        for size, target_area in target_areas.items():
            generated_area = 0
            specs = size_specs[size]
            
            while generated_area < target_area and not remaining_area.is_empty:
                # Find valid placement
                plot = self._place_plot(
                    remaining_area, 
                    specs['width'], 
                    specs['depth'],
                    road_network,
                    f"plot_{plot_id:03d}"
                )
                
                if plot:
                    plots.append(plot)
                    remaining_area = remaining_area.difference(plot.geometry.buffer(5))
                    generated_area += plot.area_sqm
                    plot_id += 1
                else:
                    break
        
        self.logger.info(f"Generated {len(plots)} varied plots")
        return plots
    
    def _place_plot(
        self,
        available_area: Polygon,
        width: float,
        depth: float,
        road_network: RoadNetwork,
        plot_id: str
    ) -> Optional[Plot]:
        """
        Try to place a single plot in available area
        """
        if available_area.is_empty:
            return None
        
        minx, miny, maxx, maxy = available_area.bounds
        
        # Try different positions
        for _ in range(50):  # Max attempts
            x = np.random.uniform(minx, maxx - width)
            y = np.random.uniform(miny, maxy - depth)
            
            plot_geom = box(x, y, x + width, y + depth)
            
            if available_area.contains(plot_geom):
                return Plot(
                    id=plot_id,
                    geometry=plot_geom,
                    area_sqm=plot_geom.area,
                    type=PlotType.INDUSTRIAL,
                    width_m=width,
                    depth_m=depth,
                    frontage_m=width,
                    has_road_access=self._check_road_access(plot_geom, road_network)
                )
        
        return None
    
    def generate_green_spaces(
        self,
        site: SiteBoundary,
        industrial_plots: List[Plot],
        road_network: RoadNetwork,
        target_ratio: float = 0.15
    ) -> List[Plot]:
        """
        Generate green space plots to meet minimum requirement
        
        Args:
            site: Site boundary
            industrial_plots: Existing industrial plots
            road_network: Road network
            target_ratio: Target green space ratio (default 15%)
            
        Returns:
            List of green space Plot objects
        """
        self.logger.info(f"Generating green spaces (target: {target_ratio*100}%)")
        
        target_area = site.buildable_area_sqm * target_ratio
        
        # Get used area
        used_polys = [p.geometry for p in industrial_plots]
        road_polys = self._get_road_polygons(road_network)
        
        all_used = unary_union(used_polys + road_polys)
        
        # Remaining area for green
        setback = self.regulations.get('setbacks', {}).get('boundary_minimum', 50)
        buildable = site.geometry.buffer(-setback)
        remaining = buildable.difference(all_used.buffer(2))
        
        green_plots = []
        
        if remaining.is_empty:
            self.logger.warning("No remaining area for green space")
            return green_plots
        
        # Convert remaining area to green plots
        if isinstance(remaining, MultiPolygon):
            polygons = list(remaining.geoms)
        else:
            polygons = [remaining]
        
        for i, poly in enumerate(polygons):
            if poly.area >= 50:  # Minimum 50 sqm for green space
                green_plot = Plot(
                    id=f"green_{i:03d}",
                    geometry=poly,
                    area_sqm=poly.area,
                    type=PlotType.GREEN_SPACE,
                    width_m=self._estimate_width(poly),
                    depth_m=self._estimate_depth(poly)
                )
                green_plots.append(green_plot)
        
        total_green = sum(p.area_sqm for p in green_plots)
        self.logger.info(
            f"Generated {len(green_plots)} green plots, "
            f"total: {total_green:.0f}m² ({total_green/site.buildable_area_sqm*100:.1f}%)"
        )
        
        return green_plots
    
    def _get_road_polygons(self, road_network: RoadNetwork) -> List[Polygon]:
        """Get road polygons from road network"""
        if not road_network:
            return []
        
        road_config = self.regulations.get('roads', {})
        primary_width = road_config.get('primary_width_m', 24)
        secondary_width = road_config.get('secondary_width_m', 16)
        
        polygons = []
        
        if road_network.primary_roads:
            roads = road_network.primary_roads.geoms if hasattr(road_network.primary_roads, 'geoms') else [road_network.primary_roads]
            for road in roads:
                if isinstance(road, LineString):
                    polygons.append(road.buffer(primary_width / 2, cap_style=2))
        
        if road_network.secondary_roads:
            roads = road_network.secondary_roads.geoms if hasattr(road_network.secondary_roads, 'geoms') else [road_network.secondary_roads]
            for road in roads:
                if isinstance(road, LineString):
                    polygons.append(road.buffer(secondary_width / 2, cap_style=2))
        
        return polygons
    
    def _check_road_access(
        self,
        plot_geom: Polygon,
        road_network: RoadNetwork,
        max_distance: float = 200
    ) -> bool:
        """Check if plot has road access within max distance"""
        if not road_network:
            return False
        
        all_roads = []
        if road_network.primary_roads:
            roads = road_network.primary_roads.geoms if hasattr(road_network.primary_roads, 'geoms') else [road_network.primary_roads]
            all_roads.extend(roads)
        if road_network.secondary_roads:
            roads = road_network.secondary_roads.geoms if hasattr(road_network.secondary_roads, 'geoms') else [road_network.secondary_roads]
            all_roads.extend(roads)
        
        for road in all_roads:
            if plot_geom.distance(road) <= max_distance:
                return True
        
        return False
    
    def _estimate_width(self, geom: Polygon) -> float:
        """Estimate plot width from geometry"""
        minx, miny, maxx, maxy = geom.bounds
        return maxx - minx
    
    def _estimate_depth(self, geom: Polygon) -> float:
        """Estimate plot depth from geometry"""
        minx, miny, maxx, maxy = geom.bounds
        return maxy - miny


# Example usage
if __name__ == "__main__":
    from src.geometry.site_processor import SiteProcessor
    from src.geometry.road_network import RoadNetworkGenerator
    
    # Create test site
    processor = SiteProcessor()
    coords = [(0, 0), (500, 0), (500, 500), (0, 500), (0, 0)]
    site = processor.import_from_coordinates(coords)
    
    # Generate road network
    road_gen = RoadNetworkGenerator()
    roads = road_gen.generate_grid_network(site, primary_spacing=150)
    
    # Generate plots
    plot_gen = PlotGenerator()
    
    # Grid plots
    grid_plots = plot_gen.generate_grid_plots(
        site, roads,
        plot_width=80,
        plot_depth=100
    )
    
    print(f"Grid plots: {len(grid_plots)}")
    total_area = sum(p.area_sqm for p in grid_plots)
    print(f"Total industrial area: {total_area:.0f}m²")
    
    # Green spaces
    green_plots = plot_gen.generate_green_spaces(
        site, grid_plots, roads,
        target_ratio=0.15
    )
    
    print(f"Green plots: {len(green_plots)}")
    green_area = sum(p.area_sqm for p in green_plots)
    print(f"Total green area: {green_area:.0f}m²")
    
    # Check road access
    with_access = sum(1 for p in grid_plots if p.has_road_access)
    print(f"Plots with road access: {with_access}/{len(grid_plots)}")