from dataclasses import dataclass
from enum import Enum
from time import sleep
from typing import Optional
import random

"""
             )  (
            (   ) )
             ) ( (
           _______)_
        .-'---------|  
       ( C|/\/\/\/\/|
        '-./\/\/\/\/|
          '_________'
           '-------'
    THE PERFECT CUP OF COFFEE
"""

class BeanType(Enum):
    ETHIOPIAN_YIRGACHEFFE = "floral and bright"
    GUATEMALA_ANTIGUA = "chocolate and spice"
    SUMATRA_MANDHELING = "earthy and deep"
    KENYA_AA = "wine-like and bright"
    COLOMBIA_SUPREMO = "caramel and nutty"

@dataclass
class CoffeeBean:
    variety: BeanType
    roast_level: float  # 0-1, light to dark
    days_since_roast: int
    
    @property
    def freshness(self) -> float:
        return max(0, 1 - (self.days_since_roast / 14))

class WaterQuality(Enum):
    TAP = "municipal water, it'll do"
    FILTERED = "clean and pure"
    MINERAL = "perfectly balanced minerals"
    SPRING = "straight from the mountains"

class CoffeeMaker:
    def __init__(self, name: str):
        self.name = name
        self.clean_level = 1.0  # Start clean!
        self.times_used = 0
        
    def clean(self):
        print(f"♨️  Cleaning {self.name}...")
        sleep(1)  # Good things take time
        self.clean_level = 1.0
        self.times_used = 0
        print("✨ Sparkly clean!")

class PerfectCup:
    """
    The quest for the perfect cup of coffee
    
         {
      {   }
       }_{ __{
    .-{   }   }-.
   (   }     {   )
   |`-.._____..-'|
   |             ;--.
   |            (__  \
   |             | )  )
   |             |/  /
   |             /  /
   |            (  /
   \             y'
    `-.._____..-'
    """
    
    def __init__(self, beans: CoffeeBean, water: WaterQuality):
        self.beans = beans
        self.water = water
        self.maker = CoffeeMaker("Chemex")  # Because we're fancy
        self.grind_size = None
        self.brew_temp = None
        self.last_message = None

    def check_water_temp(self, temp: float) -> bool:
        """
        The perfect temperature is 200°F ± 2°F
        Too hot = bitter
        Too cold = sour
        Just right = *chef's kiss*
        """
        return 198 <= temp <= 202

    def determine_grind_size(self) -> float:
        """
        Returns ideal grind size (0-1, fine to coarse)
        More art than science, but we try...
        """
        # Lighter roasts need finer grind
        base_size = 0.5 + (self.beans.roast_level * 0.2)
        # Adjust for freshness
        base_size += (1 - self.beans.freshness) * 0.1
        return min(1, max(0, base_size))

    def add_meditation_time(self):
        """
        Sometimes you just need to breathe and appreciate the moment
                    
           ~~~~~~
         ~~      ~~
        ~~        ~~
         ~~      ~~
           ~~~~~~
        """
        print("Taking a moment to appreciate the art of coffee...")
        sleep(2)

    def brew(self, water_temp: float) -> Optional[str]:
        if self.maker.clean_level < 0.7:
            self.maker.clean()
            
        if not self.check_water_temp(water_temp):
            return "Temperature is not optimal! Adjusting..."
            
        self.grind_size = self.determine_grind_size()
        self.brew_temp = water_temp
        
        # The magic happens here
        quality_score = self._calculate_quality()
        
        if quality_score >= 0.9:
            self.add_meditation_time()
            return self._generate_perfect_message()
        elif quality_score >= 0.7:
            return "A very good cup. Not perfect, but close!"
        else:
            return "Hmm... Let's try again, shall we?"

    def _calculate_quality(self) -> float:
        base_score = random.uniform(0.8, 1.0)  # We're optimists
        
        # Freshness matters!
        base_score *= (0.7 + (self.beans.freshness * 0.3))
        
        # Water quality coefficient
        water_coefficients = {
            WaterQuality.TAP: 0.8,
            WaterQuality.FILTERED: 0.9,
            WaterQuality.MINERAL: 1.0,
            WaterQuality.SPRING: 1.0
        }
        base_score *= water_coefficients[self.water]
        
        # Cleanliness is next to godliness
        base_score *= self.maker.clean_level
        
        return min(1.0, base_score)

    def _generate_perfect_message(self) -> str:
        messages = [
            "Ah, perfection in a cup! ☕",
            "The coffee gods are pleased! 🙏",
            "This... this is why we do this! ✨",
            "Time stops for a cup like this... ⏰",
            "Better than a barista's best! 🏆"
        ]
        
        # Don't repeat messages
        available_messages = [m for m in messages if m != self.last_message]
        self.last_message = random.choice(available_messages)
        return self.last_message

if __name__ == "__main__":
    # Let's make some coffee!
    beans = CoffeeBean(
        variety=BeanType.ETHIOPIA_YIRGACHEFFE,
        roast_level=0.3,  # Light roast
        days_since_roast=2  # Fresh!
    )
    
    perfect_cup = PerfectCup(
        beans=beans,
        water=WaterQuality.MINERAL
    )
    
    result = perfect_cup.brew(water_temp=200.0)
    print(result)