# Configuración Completa de IntelliJ IDEA

Esta guía explica cómo configurar IntelliJ IDEA tanto para uso general como con los plugins de IA necesarios, incluyendo cómo utilizar los archivos de instrucciones de este repositorio.

## Requisitos Previos

Antes de comenzar, asegúrate de tener:

- **IntelliJ IDEA** (versión 2021.2 o superior)
- **Cuenta de GitHub** activa (para Copilot)
- **Suscripción a GitHub Copilot** (puedes obtener una prueba gratuita)

## Instalación y Configuración Inicial

### Descarga e Instalación
1. Descargar desde [JetBrains Official](https://www.jetbrains.com/idea/)
2. Elegir entre Community (gratuita) o Ultimate (paga)
3. Seguir wizard de instalación estándar

### Primera Configuración
```
File → Settings (Windows/Linux)
IntelliJ IDEA → Preferences (macOS)
```

## Configuraciones Esenciales

### Apariencia y Tema
- **Theme**: Darcula (oscuro) o IntelliJ Light (claro)
- **Font**: JetBrains Mono, Fira Code, o Consolas
- **Font Size**: 14-16px recomendado
- **Line Height**: 1.2-1.4

### Editor
```
Editor → General
- Change font size with Ctrl+Mouse Wheel: ✓
- Show line numbers: ✓
- Show whitespaces: ✓
- Soft-wrap files: ✓

Editor → Code Style
- Right margin: 120 characters
- Indent size: 4 spaces (Java/C#), 2 spaces (JS/TS)
- Use tab character: ❌ (usar espacios)
```

## Plugins Recomendados

### Productividad General
- **Key Promoter X**: Aprende shortcuts
- **String Manipulation**: Transformaciones de texto
- **Rainbow Brackets**: Colores para brackets anidados
- **GitToolBox**: Extensiones Git avanzadas

### Plugins de IA (Esenciales)

#### GitHub Copilot (Principal)
```
Nombre: GitHub Copilot
Plugin ID: com.github.copilot
Descripción: Asistente de código con IA de GitHub
```

**Instalación:**
1. Abrir IntelliJ IDEA
2. Ir a File → Settings → Plugins (Ctrl+Alt+S)
3. Buscar "GitHub Copilot" en Marketplace
4. Instalar y reiniciar IDE
5. Autenticar con tu cuenta de GitHub

#### AI Assistant (JetBrains) - Alternativa Nativa
```
Nombre: AI Assistant
Plugin ID: com.intellij.ai
Descripción: Asistente de IA nativo de JetBrains
```

**Características:**
- Chat integrado con IA
- Generación de código contextual
- Explicación de código
- Refactoring inteligente

#### Tabnine (Alternativa)
```
Nombre: Tabnine AI Code Completion
Plugin ID: com.tabnine.TabNine
Descripción: Autocompletado con IA
```

### Lenguajes y Frameworks
- **Spring Boot**: Para desarrollo Spring
- **Lombok**: Reduce boilerplate Java
- **Docker**: Soporte para contenedores
- **Database Tools**: Conexión a BD (Ultimate)
- **Rest Client**: Testing de APIs

### Calidad de Código
- **SonarLint**: Análisis de calidad
- **CheckStyle**: Verificación de estilo
- **SpotBugs**: Detección de bugs
- **PMD**: Análisis estático

## Configuración de GitHub Copilot

### Autenticación

#### Método 1: Autenticación Web
1. **Abre la ventana de autenticación**
   - Ve a `Tools → GitHub Copilot → Login to GitHub`
   - O usa `Ctrl+Shift+A` y busca "GitHub Copilot Login"

2. **Autenticación automática**
   - Se abrirá tu navegador automáticamente
   - Inicia sesión en tu cuenta de GitHub
   - Autoriza la aplicación "GitHub Copilot"

#### Método 2: Código de Activación
1. Si el navegador no se abre automáticamente
2. Copia el código mostrado en IntelliJ
3. Ve a [github.com/login/device](https://github.com/login/device)
4. Pega el código y autoriza

### Verificar la Suscripción

Asegúrate de tener una suscripción activa:
- **GitHub Pro/Team/Enterprise**: Incluida
- **Estudiantes**: Gratuita con GitHub Student Pack
- **Desarrolladores de proyectos open source**: Gratuita
- **Otros usuarios**: Suscripción de pago requerida

### Configuración de Copilot

#### Configuraciones Básicas
1. **Ir a Settings** (Ctrl+Alt+S)
2. **Navegar a** Tools → GitHub Copilot
3. **Configurar opciones**:
   - ✅ **Enable GitHub Copilot**: Activa/desactiva Copilot
   - ✅ **Show completions automatically**: Sugerencias automáticas
   - ✅ **Accept completions with Tab**: Usar Tab para aceptar
   - ✅ **Show Copilot status in status bar**: Mostrar estado en la barra

#### Configuraciones Avanzadas
En Settings → Tools → GitHub Copilot → Advanced:

```
Max completions: 10
Temperature: 0.1
Enable logging: ✅ (para debugging)
Show inline suggestions: ✅
```

### Configuración por Lenguaje
En Settings → Editor → Language Injections:

```
Java: ✅ Enable Copilot suggestions
Kotlin: ✅ Enable Copilot suggestions
Dart: ✅ Enable Copilot suggestions
TypeScript: ✅ Enable Copilot suggestions
JavaScript: ✅ Enable Copilot suggestions
```

## Cómo Usar GitHub Copilot

### Sugerencias Automáticas

1. **Comienza a escribir código**
   - Copilot sugerirá completaciones en gris
   - Presiona `Tab` para aceptar la sugerencia completa
   - Presiona `Ctrl+→` para aceptar palabra por palabra

2. **Múltiples sugerencias**
   - Presiona `Alt+]` para ver la siguiente sugerencia
   - Presiona `Alt+[` para ver la sugerencia anterior
   - Presiona `Ctrl+Enter` para abrir el panel de sugerencias

### Chat con Copilot

1. **Abre el chat**
   - Presiona `Ctrl+Shift+A` y busca "GitHub Copilot Chat"
   - O ve a `Tools → GitHub Copilot → Open Copilot Chat`

2. **Tipos de consultas útiles:**
   ```
   Explica este código
   Optimiza esta función
   Añade tests para este método
   Corrige este error
   Refactoriza esta clase
   ```

### Shortcuts de Copilot

| Acción | Shortcut |
|--------|----------|
| Aceptar sugerencia completa | `Tab` |
| Aceptar palabra por palabra | `Ctrl + →` |
| Rechazar sugerencia | `Esc` |
| Siguiente sugerencia | `Alt + ]` |
| Sugerencia anterior | `Alt + [` |
| Abrir panel de sugerencias | `Ctrl + Enter` |
| Abrir Copilot Chat | `Ctrl + Shift + I` |

## Configuraciones por Lenguaje

### Java
```
File → Project Structure
- Project SDK: Java 17+ LTS
- Language Level: 17 o superior
- Compiler output: /target/classes

Build Tools
- Maven: Auto-import ✓
- Gradle: Auto-import ✓

Code Style → Java
- Use tab character: ❌
- Tab size: 4
- Indent: 4
- Continuation indent: 8
```

### Python
```
File → Settings → Project → Python Interpreter
- Seleccionar intérprete apropiado
- Virtual environment recomendado

Code Style → Python
- Tab size: 4
- Indent: 4
- Keep indents on empty lines: ✓
```

### JavaScript/TypeScript
```
Languages & Frameworks → TypeScript
- TypeScript Service: ✓
- Recompile on changes: ✓

Code Style → TypeScript
- Tab size: 2
- Indent: 2
- Spaces around operators: ✓
```

## Shortcuts Esenciales

### Navegación
| Acción | Windows/Linux | macOS |
|--------|---------------|-------|
| Command Palette | `Ctrl+Shift+A` | `Cmd+Shift+A` |
| Buscar en archivos | `Ctrl + Shift + F` | `Cmd + Shift + F` |
| Ir a clase | `Ctrl + N` | `Cmd + N` |
| Ir a archivo | `Ctrl + Shift + N` | `Cmd + Shift + N` |
| Ir a línea | `Ctrl + G` | `Cmd + G` |
| Navegar atrás/adelante | `Ctrl + Alt + ←/→` | `Cmd + Alt + ←/→` |

### Edición
| Acción | Windows/Linux | macOS |
|--------|---------------|-------|
| Duplicar línea | `Ctrl + D` | `Cmd + D` |
| Eliminar línea | `Ctrl + Y` | `Cmd + Backspace` |
| Mover línea | `Ctrl + Shift + ↑/↓` | `Cmd + Shift + ↑/↓` |
| Comentar/descomentar | `Ctrl + /` | `Cmd + /` |
| Autocompletar | `Ctrl + Space` | `Cmd + Space` |

### Refactoring
| Acción | Windows/Linux | macOS |
|--------|---------------|-------|
| Renombrar | `Shift + F6` | `Shift + F6` |
| Extraer método | `Ctrl + Alt + M` | `Cmd + Alt + M` |
| Extraer variable | `Ctrl + Alt + V` | `Cmd + Alt + V` |
| Inline | `Ctrl + Alt + N` | `Cmd + Alt + N` |

## Uso de Archivos de Instrucciones

### Método 1: Comentarios de Archivo
Agregar al inicio de cada archivo las instrucciones relevantes:

```java
/**
 * INSTRUCCIONES PARA COPILOT/IA:
 *
 * Seguir las convenciones de java-maven.md:
 * - Usar nomenclatura camelCase para métodos y variables
 * - Aplicar principios SOLID
 * - Documentar con JavaDoc completo
 * - Incluir validaciones de entrada
 * - Manejar excepciones apropiadamente
 * - Usar anotaciones de Spring Boot cuando corresponda
 */
public class UserService {
    // El código generado seguirá las instrucciones
}
```

### Método 2: Live Templates Personalizados
Crear Live Templates con las instrucciones:

1. **Ir a Settings** → Editor → Live Templates
2. **Crear nuevo grupo**: "AI Instructions"
3. **Agregar templates**:

```
Abbreviation: javainst
Template text:
/*
INSTRUCCIONES JAVA-MAVEN:
$INSTRUCTIONS$
*/
```

### Método 3: File Templates
Crear plantillas de archivo con instrucciones:

1. **Ir a Settings** → Editor → File and Code Templates
2. **Crear nuevo template**:

```java
#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end

/**
 * INSTRUCCIONES PARA IA:
 * Seguir convenciones de ${TEMPLATE_NAME}.md
 * - Aplicar principios SOLID
 * - Incluir validaciones apropiadas
 * - Documentar con JavaDoc
 * - Manejar errores correctamente
 */
public class ${NAME} {

}
```

## Configuración de Git

### Integración Git
```
File → Settings → Version Control → Git
- Path to Git executable: /usr/bin/git
- Use credential helper: ✓

GitHub Integration
- Add Account: Usar token personal
- Clone repositories: ✓
```

### Configuración de Merge Tool
```
File → Settings → Tools → Diff & Merge
- Use IntelliJ IDEA as merge tool
- Trust exit code: ✓
```

## Configuración de Base de Datos (Ultimate)

### Database Tool Window
```
View → Tool Windows → Database

Conectar a BD:
- Host: localhost
- Port: 5432 (PostgreSQL), 3306 (MySQL)
- Database: nombre_db
- User/Password: credenciales

Configurar:
- Auto-sync: ✓
- Show schemas in tree: ✓
```

## Configuración de Debugging

### Run/Debug Configurations
```
Run → Edit Configurations

Para Spring Boot:
- Main class: Application.main
- VM options: -Xmx1024m
- Environment variables: según necesidad
- Active profiles: dev,local

Para Tests:
- Test kind: All in package
- VM options: -ea (enable assertions)
```

## Live Templates (Snippets)

### Crear Templates Personalizados
```
File → Settings → Editor → Live Templates

Ejemplos útiles:

// Java
psvm → public static void main(String[] args) { $END$ }
sout → System.out.println($END$);
fori → for(int $INDEX$ = 0; $INDEX$ < $LIMIT$; $INDEX$++) { $END$ }

// Python
def → def $NAME$($PARAMS$): $END$
main → if __name__ == '__main__': $END$

// JavaScript
cl → console.log($END$);
fn → function $NAME$($PARAMS$) { $END$ }
```

## Configuración de Performance

### Memory Settings
```
Help → Change Memory Settings
- Heap size: 2048-4096 MB (según RAM disponible)
- Metaspace: 512 MB

VM Options (Help → Edit Custom VM Options):
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:+UnlockExperimentalVMOptions
-XX:+UseJVMCICompiler
```

### Indexing
```
File → Invalidate Caches and Restart
- Clear cached data periódicamente
- Exclude build folders from indexing
```

## Mejores Prácticas para IA

### Para Obtener Mejores Sugerencias

1. **Escribe comentarios descriptivos**
   ```java
   // Función para calcular el factorial de un número de forma recursiva
   public int factorial(int n) {
       // Copilot sugerirá la implementación
   }
   ```

2. **Usa nombres descriptivos**
   ```java
   // ✅ Bueno
   public void calculateUserMonthlyBill() {

   // ❌ Malo
   public void calc() {
   ```

3. **Proporciona contexto**
   ```java
   public class PaymentProcessor {
       // Procesar pago con tarjeta de crédito usando Stripe API
       public PaymentResult processPayment(CreditCard card, Amount amount) {
   ```

### Configuración por Tipo de Archivo

Puedes deshabilitar Copilot para ciertos tipos de archivo:

1. Ve a `Settings → Tools → GitHub Copilot`
2. En "Language Settings", desactiva los tipos que no necesites

## Flujo de Trabajo Recomendado

### 1. Configuración Inicial del Proyecto
```
1. Crear nuevo proyecto en IntelliJ
2. Configurar SDK y dependencias
3. Crear archivo de instrucciones en comentarios
4. Configurar Live Templates si es necesario
```

### 2. Durante el Desarrollo
```
1. Escribir comentarios descriptivos antes del código
2. Usar Copilot para autocompletado (Tab para aceptar)
3. Usar AI Assistant para explicaciones
4. Refactorizar con ayuda de IA
```

### 3. Revisión y Optimización
```
1. Usar AI Assistant para revisar código
2. Solicitar sugerencias de mejora
3. Verificar cumplimiento de estándares
4. Generar tests con IA
```

## Solución de Problemas

### Plugin no aparece
- Verifica que tienes IntelliJ IDEA 2021.2+
- Reinicia la IDE completamente
- Verifica la conexión a internet

### No recibo sugerencias de Copilot
1. **Verifica el estado en la barra inferior**
   - ✅ Verde: Funcionando correctamente
   - ⚠️ Amarillo: Problemas de conexión
   - ❌ Rojo: Error de autenticación

2. **Soluciones comunes:**
   - Cierra sesión y vuelve a iniciar: `Tools → GitHub Copilot → Logout`
   - Verifica tu suscripción en [github.com/settings/copilot](https://github.com/settings/copilot)
   - Reinicia IntelliJ IDEA

### Errores de autenticación
```bash
# Si ves este error:
"GitHub Copilot could not connect to server. Extension activation failed"

# Solución:
1. Ve a Tools → GitHub Copilot → Logout
2. Reinicia IntelliJ IDEA
3. Ve a Tools → GitHub Copilot → Login to GitHub
4. Completa el proceso de autenticación nuevamente
```

### Performance Issues
- Aumentar heap memory
- Excluir directorios innecesarios del indexing
- Deshabilitar plugins no utilizados
- Usar SSD para mejor I/O

### Problemas de Sincronización
- File → Reload from Disk
- Invalidate Caches and Restart
- Verificar .gitignore para archivos IDE

### Issues de Plugins
- Deshabilitar plugins conflictivos
- Actualizar a versiones compatibles
- Revisar logs: Help → Show Log in Explorer

## Plugins de Desarrollo Específicos

### Spring Boot
- Spring Boot Helper
- Spring Assistant
- Request mapper
- JPA Buddy

### Frontend
- Prettier
- ESLint
- Vue.js
- Angular
- React

### DevOps
- Kubernetes
- Terraform
- AWS Toolkit
- Azure DevOps

## Configuración de Equipo

### Compartir Configuraciones
```
File → Manage IDE Settings → Export Settings
- Seleccionar configuraciones a exportar
- Generar archivo .zip para compartir

Import Settings:
- File → Manage IDE Settings → Import Settings
- Seleccionar archivo de configuraciones
```

### EditorConfig
```
# .editorconfig en raíz del proyecto
root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true

[*.java]
indent_style = space
indent_size = 4

[*.{js,ts,json}]
indent_style = space
indent_size = 2
```

## Métricas y Monitoreo

### Estadísticas de Copilot
Ver en: View → Tool Windows → GitHub Copilot
```
- Sugerencias aceptadas/rechazadas
- Tiempo ahorrado
- Lenguajes más utilizados
- Patrones de uso
```

### Configurar Logging
Para debugging de IA:
```
Help → Diagnostic Tools → Debug Log Settings
Agregar: com.github.copilot
```

## Recursos Adicionales

- **Documentación oficial**: [GitHub Copilot Docs](https://docs.github.com/en/copilot)
- **JetBrains Plugin**: [GitHub Copilot Plugin](https://plugins.jetbrains.com/plugin/17718-github-copilot)
- **JetBrains AI Assistant**: [AI Assistant](https://www.jetbrains.com/ai/)
- **Precios**: [GitHub Copilot Pricing](https://github.com/features/copilot/pricing)
- **FAQ**: [GitHub Copilot FAQ](https://github.com/features/copilot#faq)
- **IntelliJ IDEA Tips & Tricks**: [JetBrains Guide](https://www.jetbrains.com/idea/guide/)

## Consejos Finales

1. **Sé específico**: Cuanto más contexto proporciones, mejores serán las sugerencias
2. **Revisa siempre**: Copilot es una herramienta de ayuda, siempre revisa el código sugerido
3. **Aprende gradualmente**: Comienza con casos simples y ve aumentando la complejidad
4. **Combina herramientas**: Usa Copilot junto con las funcionalidades nativas de IntelliJ
5. **Mantén actualizado**: Mantén tanto IntelliJ como los plugins de IA actualizados

---

**Consejo:** Combina las capacidades de Copilot con las herramientas nativas de IntelliJ para obtener la mejor experiencia de desarrollo asistido por IA.