DIY Helper MCP Servers

"""
Material Quantity Calculators
Calculate how much material is needed for various projects
"""

import math
from typing import Dict, Optional


class MaterialCalculator:
    """Calculate material quantities for various projects"""
    
    @staticmethod
    def calculate_wire_length(
        circuit_length_feet: float,
        num_circuits: int = 1,
        waste_factor: float = 0.15
    ) -> Dict:
        """
        Calculate electrical wire needed
        
        Args:
            circuit_length_feet: One-way distance in feet
            num_circuits: Number of circuits
            waste_factor: Percentage extra for waste/mistakes (default 15%)
        """
        # Wire needs to go and return, plus waste
        total_feet = circuit_length_feet * 2 * num_circuits
        with_waste = total_feet * (1 + waste_factor)
        
        # Round up to nearest 25 feet (common spool sizes)
        recommended_feet = math.ceil(with_waste / 25) * 25
        
        return {
            "base_feet": total_feet,
            "with_waste": with_waste,
            "recommended_feet": recommended_feet,
            "waste_factor": waste_factor,
            "note": f"Buying {recommended_feet}ft gives you buffer for mistakes and future repairs"
        }
    
    @staticmethod
    def calculate_outlets_needed(
        room_perimeter_feet: float,
        room_type: str = "living"
    ) -> Dict:
        """
        Calculate number of outlets needed per NEC
        
        Args:
            room_perimeter_feet: Total wall perimeter
            room_type: 'living', 'kitchen', 'bathroom', 'garage'
        """
        if room_type == "kitchen":
            # Kitchen countertop: outlet every 4 feet (24 inches from any point)
            # Assuming countertop is 50% of perimeter
            countertop_length = room_perimeter_feet * 0.5
            outlets = math.ceil(countertop_length / 4)
            code_ref = "NEC 210.52(C)(1)"
            note = "Kitchen countertops require outlets every 4 feet maximum"
        
        elif room_type == "bathroom":
            # Bathroom: at least 1 GFCI outlet
            outlets = max(1, math.ceil(room_perimeter_feet / 12))
            code_ref = "NEC 210.52(D)"
            note = "Bathroom requires at least one GFCI outlet, all must be GFCI protected"
        
        else:  # living, bedroom, etc.
            # General rule: outlet every 12 feet (no point more than 6 feet from outlet)
            outlets = math.ceil(room_perimeter_feet / 12)
            code_ref = "NEC 210.52(A)(1)"
            note = "Living spaces require outlets every 12 feet of wall space"
        
        return {
            "outlets_needed": outlets,
            "room_type": room_type,
            "perimeter_feet": room_perimeter_feet,
            "code_reference": code_ref,
            "note": note
        }
    
    @staticmethod
    def calculate_tile_needed(
        area_sq_ft: float,
        tile_size_inches: tuple = (12, 12),
        waste_factor: float = 0.10
    ) -> Dict:
        """
        Calculate tile needed for floor/wall
        
        Args:
            area_sq_ft: Total area to tile
            tile_size_inches: (width, height) in inches
            waste_factor: Extra for cuts/breakage (default 10%)
        """
        # Convert tile size to sq ft
        tile_width_ft = tile_size_inches[0] / 12
        tile_height_ft = tile_size_inches[1] / 12
        tile_area_sq_ft = tile_width_ft * tile_height_ft
        
        # Calculate base tiles needed
        base_tiles = math.ceil(area_sq_ft / tile_area_sq_ft)
        
        # Add waste factor
        total_tiles = math.ceil(base_tiles * (1 + waste_factor))
        
        # Calculate cases (assume 10 tiles per case typically)
        tiles_per_case = 10
        cases_needed = math.ceil(total_tiles / tiles_per_case)
        total_coverage = cases_needed * tiles_per_case * tile_area_sq_ft
        
        return {
            "area_sq_ft": area_sq_ft,
            "tile_size": f"{tile_size_inches[0]}x{tile_size_inches[1]} inches",
            "tiles_needed": total_tiles,
            "cases_needed": cases_needed,
            "total_tiles": cases_needed * tiles_per_case,
            "total_coverage_sq_ft": round(total_coverage, 1),
            "waste_factor": waste_factor,
            "note": f"Ordering {cases_needed} cases gives you {total_tiles - base_tiles} extra tiles for cuts and repairs"
        }
    
    @staticmethod
    def calculate_paint_needed(
        area_sq_ft: float,
        coats: int = 2,
        coverage_per_gallon: int = 350
    ) -> Dict:
        """
        Calculate paint needed
        
        Args:
            area_sq_ft: Total wall/ceiling area
            coats: Number of coats (default 2)
            coverage_per_gallon: Sq ft per gallon (default 350)
        """
        total_area = area_sq_ft * coats
        gallons_needed = total_area / coverage_per_gallon
        
        # Round up to nearest gallon
        gallons_to_buy = math.ceil(gallons_needed)
        
        return {
            "area_sq_ft": area_sq_ft,
            "coats": coats,
            "total_area_to_cover": total_area,
            "gallons_needed": round(gallons_needed, 2),
            "gallons_to_buy": gallons_to_buy,
            "coverage_per_gallon": coverage_per_gallon,
            "note": f"Buy {gallons_to_buy} gallon(s) for {coats} coats"
        }
    
    @staticmethod
    def calculate_lumber_for_deck(
        deck_length_ft: float,
        deck_width_ft: float,
        joist_spacing_inches: int = 16,
        board_width_inches: float = 5.5
    ) -> Dict:
        """
        Calculate lumber needed for deck framing and decking
        
        Args:
            deck_length_ft: Deck length
            deck_width_ft: Deck width
            joist_spacing_inches: Joist spacing (typically 16")
            board_width_inches: Deck board width (typically 5.5" for 2x6)
        """
        area_sq_ft = deck_length_ft * deck_width_ft
        
        # Calculate joists needed
        num_joists = math.ceil((deck_width_ft * 12) / joist_spacing_inches) + 1
        
        # Calculate deck boards needed
        board_width_ft = board_width_inches / 12
        num_boards = math.ceil(deck_length_ft / board_width_ft)
        
        # Calculate posts (assume one every 6-8 feet)
        posts_length = math.ceil(deck_length_ft / 6)
        posts_width = math.ceil(deck_width_ft / 6)
        total_posts = posts_length * posts_width
        
        return {
            "deck_size": f"{deck_length_ft}x{deck_width_ft} feet",
            "area_sq_ft": area_sq_ft,
            "joists": {
                "quantity": num_joists,
                "size": f"2x8x{math.ceil(deck_width_ft)} (or 2x10 for larger spans)",
                "spacing": f"{joist_spacing_inches} inches on center"
            },
            "decking_boards": {
                "quantity": num_boards,
                "size": f"2x6x{math.ceil(deck_width_ft)} or 5/4x6 composite",
                "note": "Add 10% for cuts and waste"
            },
            "posts": {
                "quantity": total_posts,
                "size": "4x4x10 or 4x4x12 depending on height",
                "note": "Actual quantity depends on height and local code"
            },
            "note": "This is a basic estimate. Consult building codes for beam sizes and post spacing based on deck height."
        }
    
    @staticmethod
    def calculate_pex_pipe(
        num_fixtures: int,
        avg_distance_per_fixture: float = 30,
        manifold_system: bool = True
    ) -> Dict:
        """
        Calculate PEX piping needed for plumbing
        
        Args:
            num_fixtures: Number of fixtures (sinks, toilets, etc.)
            avg_distance_per_fixture: Average run length in feet
            manifold_system: True for home-run, False for trunk-and-branch
        """
        if manifold_system:
            # Home-run: each fixture gets dedicated line from manifold
            hot_water_fixtures = math.ceil(num_fixtures * 0.6)  # ~60% need hot
            cold_water_fixtures = num_fixtures
            
            hot_pipe_feet = hot_water_fixtures * avg_distance_per_fixture
            cold_pipe_feet = cold_water_fixtures * avg_distance_per_fixture
        else:
            # Trunk-and-branch: more efficient but more complex
            hot_pipe_feet = (num_fixtures * 0.6) * avg_distance_per_fixture * 0.7
            cold_pipe_feet = num_fixtures * avg_distance_per_fixture * 0.7
        
        # Add 20% waste
        hot_total = math.ceil(hot_pipe_feet * 1.2)
        cold_total = math.ceil(cold_pipe_feet * 1.2)
        
        # Round to coil sizes (100ft or 300ft)
        def round_to_coil(feet):
            if feet <= 100:
                return 100
            elif feet <= 300:
                return 300
            else:
                return math.ceil(feet / 300) * 300
        
        hot_to_buy = round_to_coil(hot_total)
        cold_to_buy = round_to_coil(cold_total)
        
        return {
            "system_type": "Manifold (home-run)" if manifold_system else "Trunk-and-branch",
            "fixtures": num_fixtures,
            "hot_water_pipe": {
                "feet_needed": hot_total,
                "feet_to_buy": hot_to_buy,
                "size": "1/2 inch PEX",
                "color": "Red"
            },
            "cold_water_pipe": {
                "feet_needed": cold_total,
                "feet_to_buy": cold_to_buy,
                "size": "1/2 inch PEX",
                "color": "Blue"
            },
            "note": "Also budget for manifold, fittings, and crimp rings. Consider 3/4 inch for main lines."
        }