1. Caso de Estudio: Diario Digital de Emociones (Mood Tracker)

Ira:
  Nivel 1: Molestia
  Nivel 2: Enojo
  Nivel 3: Furia

Alegría:
  Nivel 1: Contento
  Nivel 2: Feliz
  Nivel 3: Eufórico

Ira:
  Nivel 1: Molestia (Annoyance)
  Nivel 2: Ira (Anger)
  Nivel 3: Furia (Rage)

Alegría:
  Nivel 1: Serenidad (Serenity)
  Nivel 2: Alegría (Joy)
  Nivel 3: Éxtasis (Ecstasy)

Excitación:
  Placer: +0.8 (intenso)
  Activación: +0.9 (alta)
  Dominancia: +0.6 (control moderado)

Depresión:
  Placer: -0.9 (muy negativo)
  Activación: -0.7 (baja energía)
  Dominancia: -0.8 (sin control)

Calma:
  Placer: +0.5 (positivo moderado)
  Activación: -0.6 (baja)
  Dominancia: +0.3 (control leve)

Paso 1: Selección de Emoción Primaria
┌─────────────────────────────────────┐
│  ¿Cómo te sientes ahora?            │
│                                     │
│  [Rueda de Plutchik interactiva]   │
│                                     │
│  Usuario selecciona: "Ira"          │
└─────────────────────────────────────┘
              ↓
Paso 2: Intensidad
┌─────────────────────────────────────┐
│  ¿Qué tan intenso es?               │
│                                     │
│  ○ Molestia (leve)                  │
│  ● Ira (moderada)                   │
│  ○ Furia (intensa)                  │
└─────────────────────────────────────┘
              ↓
Paso 3: Emoción Secundaria (Opcional)
┌─────────────────────────────────────┐
│  ¿Sientes algo más?                 │
│                                     │
│  [Mostrar emociones compatibles]    │
│  ✓ Anticipación → Agresividad       │
│  ○ Disgusto → Desprecio             │
│  ○ Ninguna                          │
└─────────────────────────────────────┘
              ↓
Paso 4: Diario Personal (Opcional)
┌─────────────────────────────────────┐
│  ¿Qué pasó hoy?                     │
│                                     │
│  [Textarea]                         │
│  "Hoy me caí de la bici, estoy mal, │
│   me siento inútil"                 │
│                                     │
│  [Guardar]  [Cancelar]              │
└─────────────────────────────────────┘

Paso 1: Placer
┌─────────────────────────────────────┐
│  ¿Qué tan placentero/desagradable?  │
│                                     │
│  Muy desagradable ●────────○ Muy placentero
│                   -1       0       +1
└─────────────────────────────────────┘
              ↓
Paso 2: Activación
┌─────────────────────────────────────┐
│  ¿Qué tan activado/calmado?         │
│                                     │
│  Muy calmado ○────●────○ Muy activado
│              -1    0    +1          │
└─────────────────────────────────────┘
              ↓
Paso 3: Dominancia
┌─────────────────────────────────────┐
│  ¿Qué tan en control?               │
│                                     │
│  Sin control ○────────●○ Total control
│              -1       0  +1         │
└─────────────────────────────────────┘
              ↓
Paso 4: Vista Previa + Diario
┌─────────────────────────────────────┐
│  Tu emoción:                        │
│  [Cubo 3D mostrando punto]          │
│                                     │
│  Emoción detectada: "Excitación"    │
│                                     │
│  [Textarea para diario]             │
│  [Guardar]                          │
└─────────────────────────────────────┘

// components/EmotionWheel.tsx
interface EmotionWheelProps {
  onSelect: (emotion: PlutchikEmotion) => void;
  selectedEmotion?: PlutchikEmotion;
}

const EmotionWheel: React.FC<EmotionWheelProps> = ({ onSelect, selectedEmotion }) => {
  const emotions = [
    { name: 'Joy', color: '#FFD700', angle: 0 },
    { name: 'Trust', color: '#90EE90', angle: 45 },
    { name: 'Fear', color: '#00CED1', angle: 90 },
    { name: 'Surprise', color: '#4169E1', angle: 135 },
    { name: 'Sadness', color: '#4B0082', angle: 180 },
    { name: 'Disgust', color: '#8B008B', angle: 225 },
    { name: 'Anger', color: '#DC143C', angle: 270 },
    { name: 'Anticipation', color: '#FF8C00', angle: 315 }
  ];

  return (
    <svg width="400" height="400" viewBox="0 0 400 400">
      {emotions.map((emotion, index) => (
        <EmotionPetal
          key={emotion.name}
          emotion={emotion}
          isSelected={selectedEmotion?.name === emotion.name}
          onClick={() => onSelect(emotion)}
        />
      ))}
    </svg>
  );
};

// utils/emotionMapping.ts
const ekmanToPlutchik = {
  'Joy': 'Joy',
  'Sadness': 'Sadness',
  'Anger': 'Anger',
  'Fear': 'Fear',
  'Surprise': 'Surprise',
  'Disgust': 'Disgust'
};

const plutchikToPAD = {
  'Joy': { pleasure: 0.8, arousal: 0.6, dominance: 0.5 },
  'Sadness': { pleasure: -0.7, arousal: -0.5, dominance: -0.6 },
  'Anger': { pleasure: -0.6, arousal: 0.8, dominance: 0.7 },
  // ... resto de mapeos
};

backend/
├── domain/                     # CORE (Lógica de Negocio)
│   ├── emociones/
│   │   ├── entities/
│   │   │   ├── emotion.entity.py
│   │   │   ├── emotion-entry.entity.py
│   │   │   └── emotion-model.entity.py
│   │   ├── repositories/
│   │   │   └── emotion.repository.interface.py
│   │   └── use-cases/
│   │       ├── register-emotion.use-case.py
│   │       ├── get-emotion-history.use-case.py
│   │       └── analyze-patterns.use-case.py
│   │
│   └── patrones/
│       ├── entities/
│       │   └── pattern.entity.py
│       └── use-cases/
│           └── detect-patterns.use-case.py
│
├── infrastructure/             # ADAPTERS
│   ├── database/
│   │   ├── postgres.service.py
│   │   └── repositories/
│   │       └── postgres-emotion.repository.py
│   │
│   ├── auth/
│   │   └── google-oauth.service.py
│   │
│   └── ml/
│       └── pattern-analyzer.service.py
│
└── presentation/               # API (FastAPI)
    ├── routers/
    │   ├── auth.router.py
    │   ├── emotions.router.py
    │   └── analytics.router.py
    └── schemas/
        └── emotion.schema.py

1. Usuario click "Login con Google"
   ↓
2. Redirect a Google OAuth
   ↓
3. Usuario autoriza la app
   ↓
4. Google devuelve Authorization Code
   ↓
5. Backend intercambia Code por Access Token
   ↓
6. Backend crea/actualiza usuario en DB
   ↓
7. Backend genera JWT propio
   ↓
8. Frontend almacena JWT en httpOnly cookie
   ↓
9. Todas las requests incluyen JWT

# infrastructure/auth/google-oauth.service.py
from authlib.integrations.starlette_client import OAuth

oauth = OAuth()
oauth.register(
    name='google',
    client_id=settings.GOOGLE_CLIENT_ID,
    client_secret=settings.GOOGLE_CLIENT_SECRET,
    server_metadata_url='https://accounts.google.com/.well-known/openid-configuration',
    client_kwargs={'scope': 'openid email profile'}
)

# presentation/routers/auth.router.py
@router.get('/login/google')
async def login_google(request: Request):
    redirect_uri = request.url_for('auth_google_callback')
    return await oauth.google.authorize_redirect(request, redirect_uri)

@router.get('/auth/google/callback')
async def auth_google_callback(request: Request):
    token = await oauth.google.authorize_access_token(request)
    user_info = token['userinfo']

    # Crear/actualizar usuario
    user = await user_service.get_or_create_user(
        email=user_info['email'],
        name=user_info['name'],
        picture=user_info['picture']
    )

    # Generar JWT
    jwt_token = create_jwt_token(user.id)

    response = RedirectResponse(url='/dashboard')
    response.set_cookie(
        key='access_token',
        value=jwt_token,
        httponly=True,
        secure=True,
        samesite='lax'
    )
    return response

# domain/emociones/entities/emotion-entry.entity.py
from cryptography.fernet import Fernet

class EmotionEntry:
    def __init__(
        self,
        user_id: str,
        emotion: Emotion,
        diary_text: Optional[str] = None,
        timestamp: datetime = datetime.now()
    ):
        self.user_id = user_id
        self.emotion = emotion
        self._diary_text_encrypted = self._encrypt(diary_text) if diary_text else None
        self.timestamp = timestamp

    def _encrypt(self, text: str) -> bytes:
        cipher = Fernet(settings.ENCRYPTION_KEY)
        return cipher.encrypt(text.encode())

    def _decrypt(self, encrypted: bytes) -> str:
        cipher = Fernet(settings.ENCRYPTION_KEY)
        return cipher.decrypt(encrypted).decode()

    @property
    def diary_text(self) -> Optional[str]:
        if self._diary_text_encrypted:
            return self._decrypt(self._diary_text_encrypted)
        return None

# Mal ❌
logger.info(f"User {user.email} registered emotion: {emotion.name}")

# Bien ✅
logger.info(f"User {user.id} registered emotion successfully")

# presentation/schemas/emotion.schema.py
from pydantic import BaseModel, Field, validator
from enum import Enum
from datetime import datetime

class EmotionModel(str, Enum):
    EKMAN = "ekman"
    PLUTCHIK = "plutchik"
    PAD = "pad"

class EkmanEmotion(str, Enum):
    JOY = "joy"
    SADNESS = "sadness"
    ANGER = "anger"
    FEAR = "fear"
    SURPRISE = "surprise"
    DISGUST = "disgust"

class RegisterEmotionRequest(BaseModel):
    model: EmotionModel
    emotion_data: dict
    diary_text: Optional[str] = Field(None, max_length=5000)
    timestamp: Optional[datetime] = None

    @validator('diary_text')
    def sanitize_diary_text(cls, v):
        if v:
            # Eliminar scripts y HTML peligroso
            import bleach
            return bleach.clean(v, tags=[], strip=True)
        return v

    @validator('emotion_data')
    def validate_emotion_data(cls, v, values):
        model = values.get('model')

        if model == EmotionModel.EKMAN:
            if 'emotion' not in v or 'intensity' not in v:
                raise ValueError('Ekman model requires emotion and intensity')
            if v['emotion'] not in [e.value for e in EkmanEmotion]:
                raise ValueError(f'Invalid Ekman emotion: {v["emotion"]}')
            if not 1 <= v['intensity'] <= 3:
                raise ValueError('Intensity must be between 1 and 3')

        elif model == EmotionModel.PAD:
            required = ['pleasure', 'arousal', 'dominance']
            if not all(k in v for k in required):
                raise ValueError(f'PAD model requires: {required}')
            for axis in required:
                if not -1 <= v[axis] <= 1:
                    raise ValueError(f'{axis} must be between -1 and 1')

        return v

# infrastructure/ml/pattern-analyzer.service.py
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import pandas as pd
import numpy as np

class PatternAnalyzerService:
    def __init__(self):
        self.scaler = StandardScaler()
        self.kmeans = None

    def detect_patterns(self, emotion_entries: List[EmotionEntry]) -> List[Pattern]:
        # Convertir a DataFrame
        df = self._entries_to_dataframe(emotion_entries)

        # Feature engineering
        features = self._extract_features(df)

        # Normalizar
        features_scaled = self.scaler.fit_transform(features)

        # Clustering
        optimal_k = self._find_optimal_k(features_scaled)
        self.kmeans = KMeans(n_clusters=optimal_k, random_state=42)
        clusters = self.kmeans.fit_predict(features_scaled)

        # Interpretar clusters
        patterns = self._interpret_clusters(df, clusters)

        return patterns

    def _extract_features(self, df: pd.DataFrame) -> np.ndarray:
        features = []

        # Hora del día (sin encoding)
        features.append(df['hour'].values)

        # Día de la semana (one-hot)
        day_onehot = pd.get_dummies(df['day_of_week'], prefix='day')
        features.append(day_onehot.values)

        # Emoción (one-hot o embedding)
        emotion_onehot = pd.get_dummies(df['emotion'], prefix='emotion')
        features.append(emotion_onehot.values)

        # Intensidad normalizada
        features.append(df['intensity_normalized'].values.reshape(-1, 1))

        return np.hstack(features)

    def _find_optimal_k(self, features: np.ndarray) -> int:
        # Método del codo (Elbow Method)
        inertias = []
        K_range = range(2, min(10, len(features) // 5))

        for k in K_range:
            kmeans = KMeans(n_clusters=k, random_state=42)
            kmeans.fit(features)
            inertias.append(kmeans.inertia_)

        # Encontrar el "codo" (simplificado)
        # En producción, usar métodos más sofisticados
        return 3  # Por defecto, 3 clusters

    def _interpret_clusters(self, df: pd.DataFrame, clusters: np.ndarray) -> List[Pattern]:
        patterns = []

        for cluster_id in range(max(clusters) + 1):
            cluster_mask = clusters == cluster_id
            cluster_data = df[cluster_mask]

            # Analizar características del cluster
            most_common_emotion = cluster_data['emotion'].mode()[0]
            most_common_hour = int(cluster_data['hour'].mode()[0])
            most_common_day = cluster_data['day_of_week'].mode()[0]
            avg_intensity = cluster_data['intensity_normalized'].mean()

            pattern = Pattern(
                id=f"pattern_{cluster_id}",
                description=f"Tiendes a sentir {most_common_emotion} los {most_common_day} alrededor de las {most_common_hour}:00",
                emotion=most_common_emotion,
                time_of_day=most_common_hour,
                day_of_week=most_common_day,
                intensity=avg_intensity,
                confidence=len(cluster_data) / len(df),  # % de datos en este cluster
                occurrences=len(cluster_data)
            )

            patterns.append(pattern)

        return sorted(patterns, key=lambda p: p.confidence, reverse=True)

{
  "patterns": [
    {
      "id": "pattern_0",
      "description": "Tiendes a sentir tristeza los lunes alrededor de las 9:00",
      "emotion": "sadness",
      "time_of_day": 9,
      "day_of_week": "monday",
      "intensity": 0.7,
      "confidence": 0.45,
      "occurrences": 12
    },
    {
      "id": "pattern_1",
      "description": "Tiendes a sentir alegría los viernes alrededor de las 18:00",
      "emotion": "joy",
      "time_of_day": 18,
      "day_of_week": "friday",
      "intensity": 0.8,
      "confidence": 0.35,
      "occurrences": 9
    }
  ]
}

// components/EmotionCalendarHeatmap.tsx
import { useMemo } from 'react';
import { scaleLinear } from 'd3-scale';

interface EmotionCalendarHeatmapProps {
  data: EmotionEntry[];
  startDate: Date;
  endDate: Date;
}

const EmotionCalendarHeatmap: React.FC<EmotionCalendarHeatmapProps> = ({
  data,
  startDate,
  endDate
}) => {
  const heatmapData = useMemo(() => {
    // Agrupar por día
    const grouped = data.reduce((acc, entry) => {
      const date = entry.timestamp.toISOString().split('T')[0];
      if (!acc[date]) {
        acc[date] = { emotions: [], avgIntensity: 0 };
      }
      acc[date].emotions.push(entry.emotion);
      return acc;
    }, {} as Record<string, { emotions: string[], avgIntensity: number }>);

    // Calcular intensidad promedio por día
    Object.keys(grouped).forEach(date => {
      const emotions = grouped[date].emotions;
      const intensities = emotions.map(e => getEmotionValence(e));
      grouped[date].avgIntensity = intensities.reduce((a, b) => a + b, 0) / intensities.length;
    });

    return grouped;
  }, [data]);

  const colorScale = scaleLinear<string>()
    .domain([-1, 0, 1])
    .range(['#DC143C', '#FFFFFF', '#90EE90']); // Rojo → Blanco → Verde

  return (
    <div className="calendar-heatmap">
      {/* Renderizar grid de días */}
      {generateDateRange(startDate, endDate).map(date => {
        const dateStr = date.toISOString().split('T')[0];
        const dayData = heatmapData[dateStr];
        const color = dayData 
          ? colorScale(dayData.avgIntensity)
          : '#F5F5F5';

        return (
          <div
            key={dateStr}
            className="calendar-day"
            style={{ backgroundColor: color }}
            title={`${dateStr}: ${dayData?.emotions.join(', ') || 'Sin datos'}`}
          />
        );
      })}
    </div>
  );
};

function getEmotionValence(emotion: string): number {
  const valenceMap: Record<string, number> = {
    'joy': 0.8,
    'trust': 0.6,
    'anticipation': 0.4,
    'surprise': 0.2,
    'sadness': -0.6,
    'disgust': -0.7,
    'anger': -0.8,
    'fear': -0.5
  };
  return valenceMap[emotion] || 0;
}

// components/EmotionTimeline.tsx
import { LineChart, Line, XAxis, YAxis, Tooltip, Legend } from 'recharts';

interface EmotionTimelineProps {
  data: EmotionEntry[];
}

const EmotionTimeline: React.FC<EmotionTimelineProps> = ({ data }) => {
  const chartData = useMemo(() => {
    return data.map(entry => ({
      date: entry.timestamp.toLocaleDateString(),
      valence: getEmotionValence(entry.emotion.name),
      arousal: entry.emotion.intensity / 3, // Normalizar 1-3 a 0-1
      emotion: entry.emotion.name
    }));
  }, [data]);

  return (
    <LineChart width={800} height={400} data={chartData}>
      <XAxis dataKey="date" />
      <YAxis domain={[-1, 1]} />
      <Tooltip content={<CustomTooltip />} />
      <Legend />
      <Line 
        type="monotone" 
        dataKey="valence" 
        stroke="#8884d8" 
        name="Valencia Emocional"
        strokeWidth={2}
      />
      <Line 
        type="monotone" 
        dataKey="arousal" 
        stroke="#82ca9d" 
        name="Intensidad"
        strokeWidth={2}
      />
    </LineChart>
  );
};

# tests/domain/patrones/test_detect_patterns.py
import pytest
from domain.emociones.entities.emotion import Emotion, EkmanEmotion
from domain.emociones.entities.emotion_entry import EmotionEntry
from domain.patrones.use_cases.detect_patterns import DetectPatternsUseCase
from datetime import datetime, timedelta

class TestDetectPatterns:
    def test_should_detect_monday_morning_sadness_pattern(self):
        # Arrange
        use_case = DetectPatternsUseCase()

        # Crear 10 entradas de tristeza los lunes a las 9am
        entries = []
        base_date = datetime(2024, 1, 1, 9, 0)  # Lunes 9am
        for i in range(10):
            date = base_date + timedelta(weeks=i)
            entry = EmotionEntry(
                user_id="user123",
                emotion=Emotion(EkmanEmotion.SADNESS, intensity=2),
                timestamp=date
            )
            entries.append(entry)

        # Act
        patterns = use_case.execute(entries)

        # Assert
        assert len(patterns) > 0
        monday_pattern = next(
            (p for p in patterns if p.day_of_week == 'monday' and p.time_of_day == 9),
            None
        )
        assert monday_pattern is not None
        assert monday_pattern.emotion == 'sadness'
        assert monday_pattern.confidence > 0.7

    def test_should_not_detect_pattern_with_insufficient_data(self):
        # Arrange
        use_case = DetectPatternsUseCase()

        # Solo 2 entradas (insuficiente)
        entries = [
            EmotionEntry(
                user_id="user123",
                emotion=Emotion(EkmanEmotion.JOY, intensity=3),
                timestamp=datetime(2024, 1, 1, 10, 0)
            ),
            EmotionEntry(
                user_id="user123",
                emotion=Emotion(EkmanEmotion.SADNESS, intensity=1),
                timestamp=datetime(2024, 1, 2, 15, 0)
            )
        ]

        # Act
        patterns = use_case.execute(entries)

        # Assert
        assert len(patterns) == 0 or all(p.confidence < 0.5 for p in patterns)