from datetime import date, datetime
from typing import Optional
from health.services.manual_log_storage import ManualLogStorage
from health.models.manual_log import (
    DietEntry, 
    AlcoholEntry, 
    SupplementEntry, 
    BodyFeelingEntry
)
from health.utils.logging_config import setup_logger

logger = setup_logger(__name__)

class HealthWriter:
    @staticmethod
    def log_diet(
        target_date: str,
        description: str,
        time: Optional[str] = None,
        meal_type: str = "snack"
    ) -> str:
        """Log a diet entry."""
        try:
            date_obj = date.fromisoformat(target_date)
            time_str = time or datetime.now().strftime("%H:%M")
            
            entry = DietEntry(
                time=time_str,
                description=description,
                meal_type=meal_type
            )
            
            storage = ManualLogStorage()
            storage.add_diet_entry(date_obj, entry)
            return f"✅ Logged diet for {target_date}: {description}"
        except Exception as e:
            logger.error(f"Failed to log diet: {e}")
            return f"❌ Error logging diet: {str(e)}"

    @staticmethod
    def log_alcohol(
        target_date: str,
        alcohol_type: str,
        amount: str,
        time: Optional[str] = None
    ) -> str:
        """Log alcohol consumption."""
        try:
            date_obj = date.fromisoformat(target_date)
            time_str = time or datetime.now().strftime("%H:%M")
            
            entry = AlcoholEntry(
                time=time_str,
                alcohol_type=alcohol_type,
                amount=amount
            )
            
            storage = ManualLogStorage()
            storage.add_alcohol_entry(date_obj, entry)
            return f"✅ Logged alcohol for {target_date}: {amount} {alcohol_type}"
        except Exception as e:
            logger.error(f"Failed to log alcohol: {e}")
            return f"❌ Error logging alcohol: {str(e)}"

    @staticmethod
    def log_supplement(
        target_date: str,
        name: str,
        dosage: str,
        time: Optional[str] = None
    ) -> str:
        """Log supplement."""
        try:
            date_obj = date.fromisoformat(target_date)
            time_str = time or datetime.now().strftime("%H:%M")
            
            entry = SupplementEntry(
                time=time_str,
                supplement_name=name,
                dosage=dosage
            )
            
            storage = ManualLogStorage()
            storage.add_supplement_entry(date_obj, entry)
            return f"✅ Logged supplement for {target_date}: {name} ({dosage})"
        except Exception as e:
            logger.error(f"Failed to log supplement: {e}")
            return f"❌ Error logging supplement: {str(e)}"

    @staticmethod
    def log_feeling(
        target_date: str,
        feeling_type: str,
        severity: int,
        description: str,
        time: Optional[str] = None
    ) -> str:
        """Log body feeling/symptom."""
        try:
            date_obj = date.fromisoformat(target_date)
            time_str = time or datetime.now().strftime("%H:%M")
            
            entry = BodyFeelingEntry(
                time=time_str,
                feeling_type=feeling_type,
                severity=severity,
                description=description
            )
            
            storage = ManualLogStorage()
            storage.add_feeling_entry(date_obj, entry)
            return f"✅ Logged feeling for {target_date}: {feeling_type} (Level {severity})"
        except Exception as e:
            logger.error(f"Failed to log feeling: {e}")
            return f"❌ Error logging feeling: {str(e)}"

    @staticmethod
    def log_fasting(
        target_date: str,
        mode: str,
        notes: Optional[str] = None
    ) -> str:
        """Log fasting mode."""
        try:
            date_obj = date.fromisoformat(target_date)
            storage = ManualLogStorage()
            # Note: The underlying storage method set_fasting_mode only takes date and mode
            # If notes were important, we'd need to update the model. 
            # For now we'll just log the mode.
            storage.set_fasting_mode(date_obj, mode)
            return f"✅ Set fasting mode for {target_date}: {mode}"
        except Exception as e:
            logger.error(f"Failed to set fasting mode: {e}")
            return f"❌ Error setting fasting mode: {str(e)}"