graph TD
    A[Análise de Requisitos] --> B[Projeto do Sistema]
    B --> C[Implementação]
    C --> D[Testes]
    D --> E[Implantação]
    E --> F[Manutenção]

graph TD
    A[Requisitos] --> B[Projeto do Sistema]
    B --> C[Projeto Detalhado]
    C --> D[Implementação]
    D --> E[Teste de Unidade]
    E --> F[Teste de Integração]
    F --> G[Teste de Sistema]
    G --> H[Teste de Aceitação]

# Exemplo de backlog de produto em Scrum
class ProductBacklogItem:
    def __init__(self, id, descricao, prioridade, estimativa, valor_negocio):
        self.id = id
        self.descricao = descricao
        self.prioridade = prioridade
        self.estimativa = estimativa  # Pontos de história
        self.valor_negocio = valor_negocio
        self.estado = "não iniciado"

class Sprint:
    def __init__(self, numero, duracao_semanas, objetivo):
        self.numero = numero
        self.duracao_semanas = duracao_semanas
        self.objetivo = objetivo
        self.itens = []
        self.data_inicio = None
        self.data_fim = None
    
    def adicionar_item(self, item):
        """Adiciona item ao sprint backlog"""
        self.itens.append(item)
        item.estado = "em andamento"

# Exemplo de implementação de sprint
sprint_atual = Sprint(1, 2, "Implementar sistema de login")
sprint_atual.adicionar_item(ProductBacklogItem(
    1, "Login de usuário com validação", 1, 5, "Alto"
))

# Exemplo de violação do SRP
class UsuarioSRPViolacao:
    def __init__(self, nome, email):
        self.nome = nome
        self.email = email
    
    def salvar_no_banco(self):
        # Lógica de persistência
        pass
    
    def enviar_email(self):
        # Lógica de envio de email
        pass
    
    def gerar_relatorio(self):
        # Lógica de geração de relatório
        pass

# Exemplo de aplicação correta do SRP
class Usuario:
    def __init__(self, nome, email):
        self.nome = nome
        self.email = email

class UsuarioRepositorio:
    def salvar(self, usuario):
        # Lógica de persistência
        pass
    
    def buscar_por_email(self, email):
        # Lógica de busca
        pass

class ServicoEmail:
    def enviar(self, destinatario, assunto, corpo):
        # Lógica de envio de email
        pass

class GeradorRelatorio:
    def gerar(self, usuarios):
        # Lógica de geração de relatório
        pass

from abc import ABC, abstractmethod

class Forma(ABC):
    @abstractmethod
    def calcular_area(self):
        pass

class Retangulo(Forma):
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura = altura
    
    def calcular_area(self):
        return self.largura * self.altura

class Circulo(Forma):
    def __init__(self, raio):
        self.raio = raio
    
    def calcular_area(self):
        return 3.14159 * self.raio ** 2

# Novas formas podem ser adicionadas sem modificar o código existente
class Triangulo(Forma):
    def __init__(self, base, altura):
        self.base = base
        self.altura = altura
    
    def calcular_area(self):
        return (self.base * self.altura) / 2

# Função que trabalha com qualquer forma (extensibilidade)
def calcular_area_total(formas):
    return sum(forma.calcular_area() for forma in formas)

# Exemplo de DIP
class NotificacaoService:
    def __init__(self, provedor_notificacao):
        self.provedor = provedor_notificacao  # Injeção de dependência
    
    def enviar_notificacao(self, mensagem, destinatario):
        self.provedor.enviar(mensagem, destinatario)

class ProvedorEmail:
    def enviar(self, mensagem, destinatario):
        print(f"Enviando email para {destinatario}: {mensagem}")

class ProvedorSMS:
    def enviar(self, mensagem, destinatario):
        print(f"Enviando SMS para {destinatario}: {mensagem}")

# O serviço não depende de implementações específicas
notificacao_email = NotificacaoService(ProvedorEmail())
notificacao_sms = NotificacaoService(ProvedorSMS())

# Exemplo de arquitetura em camadas
class EntidadeUsuario:
    def __init__(self, id, nome, email):
        self.id = id
        self.nome = nome
        self.email = email

# Camada de dados
class UsuarioRepositorio:
    def __init__(self, conexao_banco):
        self.conexao = conexao_banco
    
    def salvar(self, usuario):
        # Lógica de persistência
        pass
    
    def buscar_por_id(self, id):
        # Lógica de busca
        pass

# Camada de negócio
class ServicoUsuario:
    def __init__(self, repositorio):
        self.repositorio = repositorio
    
    def criar_usuario(self, nome, email):
        # Validações de negócio
        if not email or '@' not in email:
            raise ValueError("Email inválido")
        
        usuario = EntidadeUsuario(None, nome, email)
        return self.repositorio.salvar(usuario)
    
    def atualizar_perfil(self, id, dados_atualizados):
        # Lógica de negócio
        pass

# Camada de apresentação
class ControladorUsuario:
    def __init__(self, servico_usuario):
        self.servico = servico_usuario
    
    def criar_usuario(self, dados):
        try:
            usuario = self.servico.criar_usuario(
                dados['nome'], 
                dados['email']
            )
            return {"sucesso": True, "usuario": usuario}
        except ValueError as e:
            return {"sucesso": False, "erro": str(e)}

from abc import ABC, abstractmethod

# Portas (interfaces)
class PortaUsuario(ABC):
    @abstractmethod
    def buscar_usuario(self, id):
        pass
    
    @abstractmethod
    def salvar_usuario(self, usuario):
        pass

class PortaEmail(ABC):
    @abstractmethod
    def enviar_email(self, destinatario, assunto, corpo):
        pass

# Lógica de negócio (núcleo)
class ServicoCadastroUsuario:
    def __init__(self, porta_usuario, porta_email):
        self.porta_usuario = porta_usuario
        self.porta_email = porta_email
    
    def cadastrar(self, nome, email):
        # Lógica de negócio
        usuario = self.porta_usuario.salvar_usuario({
            'nome': nome,
            'email': email
        })
        
        self.porta_email.enviar_email(
            email, 
            "Bem-vindo!", 
            f"Olá {nome}, seja bem-vindo!"
        )
        
        return usuario

# Adaptadores (implementações concretas)
class AdaptadorUsuarioBanco(PortaUsuario):
    def buscar_usuario(self, id):
        # Implementação com banco de dados
        pass
    
    def salvar_usuario(self, usuario):
        # Implementação com banco de dados
        pass

class AdaptadorEmailSMTP(PortaEmail):
    def enviar_email(self, destinatario, assunto, corpo):
        # Implementação com SMTP
        pass

# Configuração
servico = ServicoCadastroUsuario(
    AdaptadorUsuarioBanco(),
    AdaptadorEmailSMTP()
)

# Exemplo conceitual de microsserviços
import requests

class ServicoUsuario:
    """Serviço independente de gerenciamento de usuários"""
    
    def __init__(self, url_base):
        self.url_base = url_base
    
    def obter_usuario(self, id):
        resposta = requests.get(f"{self.url_base}/usuarios/{id}")
        return resposta.json()
    
    def criar_usuario(self, dados):
        resposta = requests.post(f"{self.url_base}/usuarios", json=dados)
        return resposta.json()

class ServicoNotificacao:
    """Serviço independente de notificações"""
    
    def __init__(self, url_base):
        self.url_base = url_base
    
    def enviar_notificacao(self, usuario_id, mensagem):
        dados = {
            'usuario_id': usuario_id,
            'mensagem': mensagem
        }
        resposta = requests.post(f"{self.url_base}/notificacoes", json=dados)
        return resposta.json()

class Orquestrador:
    """Coordenador que chama serviços independentes"""
    
    def __init__(self):
        self.servico_usuario = ServicoUsuario("http://servico-usuarios:3000")
        self.servico_notificacao = ServicoNotificacao("http://servico-notificacoes:3001")
    
    def cadastrar_usuario_com_notificacao(self, dados_usuario):
        # Cria usuário
        usuario = self.servico_usuario.criar_usuario(dados_usuario)
        
        # Envia notificação
        self.servico_notificacao.enviar_notificacao(
            usuario['id'], 
            "Bem-vindo ao sistema!"
        )
        
        return usuario

# Exemplo de pipeline CI/CD com GitHub Actions
name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'
    
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
        pip install pytest pytest-cov
    
    - name: Run tests
      run: pytest --cov=src --cov-report=xml
    
    - name: Upload coverage
      uses: codecov/codecov-action@v3
    
    - name: Security scan
      run: bandit -r src/
  
  build:
    needs: test
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Build Docker image
      run: |
        docker build -t minha-app:${{ github.sha }} .
        docker tag minha-app:${{ github.sha }} minha-app:latest
    
    - name: Push to registry
      run: |
        echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
        docker push minha-app:${{ github.sha }}
  
  deploy:
    needs: build
    runs-on: ubuntu-latest
    environment: production
    
    steps:
    - name: Deploy to production
      run: |
        # Comandos de deploy (ex: kubectl, aws, etc.)
        echo "Deploy realizado com sucesso!"

# Exemplo de boas práticas em revisão de código
def calcular_desconto(valor, tipo_cliente):
    """
    Calcula desconto com base no tipo de cliente.
    
    Args:
        valor (float): Valor original
        tipo_cliente (str): Tipo do cliente
    
    Returns:
        float: Valor com desconto aplicado
    """
    if valor <= 0:
        raise ValueError("Valor deve ser positivo")
    
    if tipo_cliente == "premium":
        desconto = 0.15
    elif tipo_cliente == "gold":
        desconto = 0.10
    elif tipo_cliente == "silver":
        desconto = 0.05
    else:
        desconto = 0.0
    
    return valor * (1 - desconto)

# Exemplo de revisão:
# ✅ Documentação clara
# ✅ Validação de entrada
# ✅ Lógica bem estruturada
# ✅ Nomes de variáveis descritivos

# Exemplo de ferramentas de análise de código
# Python
pip install flake8 black mypy bandit

# Análise de estilo
flake8 src/

# Formatação automática
black src/

# Tipagem estática
mypy src/

# Análise de segurança
bandit -r src/

# JavaScript
npm install eslint prettier jest

# Análise de código
npx eslint src/

# Formatação
npx prettier --write src/

# Exemplo de práticas de segurança
import sqlite3
from werkzeug.security import check_password_hash, generate_password_hash

def validar_entrada(usuario_input):
    """Valida entrada do usuário para prevenir injeção de código"""
    if not isinstance(usuario_input, str):
        raise ValueError("Entrada deve ser string")
    
    # Remover caracteres perigosos
    entrada_sanitizada = usuario_input.strip()
    
    # Validar formato (ex: email)
    if '@' not in entrada_sanitizada:
        raise ValueError("Formato inválido")
    
    return entrada_sanitizada

def autenticar_usuario(usuario, senha):
    """Autenticação segura com hashing de senha"""
    conexao = sqlite3.connect('banco.db')
    cursor = conexao.cursor()
    
    # Usar consultas parametrizadas para prevenir SQL injection
    cursor.execute(
        "SELECT senha_hash FROM usuarios WHERE nome = ?",
        (usuario,)
    )
    resultado = cursor.fetchone()
    
    if resultado and check_password_hash(resultado[0], senha):
        return True
    return False

def criar_usuario_seguro(nome, email, senha):
    """Criação de usuário com segurança"""
    conexao = sqlite3.connect('banco.db')
    cursor = conexao.cursor()
    
    # Validar entrada
    nome = validar_entrada(nome)
    email = validar_entrada(email)
    
    # Hash da senha
    senha_hash = generate_password_hash(senha)
    
    # Inserção segura
    cursor.execute(
        "INSERT INTO usuarios (nome, email, senha_hash) VALUES (?, ?, ?)",
        (nome, email, senha_hash)
    )
    
    conexao.commit()
    conexao.close()

# Projeto: Sistema de Gerenciamento de Tarefas

# 1. Definir requisitos e arquitetura
"""
Requisitos:
- Criar, ler, atualizar e deletar tarefas
- Atribuir tarefas a usuários
- Marcar tarefas como concluídas
- Filtrar tarefas por status e usuário

Arquitetura:
- Camada de apresentação (API REST)
- Camada de negócio (lógica de tarefas)
- Camada de dados (repositório de tarefas)
"""

# 2. Implementar com princípios de engenharia
from datetime import datetime
from enum import Enum
from typing import List, Optional
import sqlite3

class StatusTarefa(Enum):
    PENDENTE = "pendente"
    EM_ANDAMENTO = "em_andamento"
    CONCLUIDA = "concluida"

class Tarefa:
    def __init__(self, id: Optional[int], titulo: str, descricao: str, 
                 usuario_id: int, data_criacao: datetime, 
                 status: StatusTarefa = StatusTarefa.PENDENTE):
        self.id = id
        self.titulo = titulo
        self.descricao = descricao
        self.usuario_id = usuario_id
        self.data_criacao = data_criacao
        self.status = status

class RepositorioTarefas:
    """Camada de dados - abstrai o acesso ao banco de dados"""
    
    def __init__(self, conexao_db: sqlite3.Connection):
        self.conexao = conexao_db
        self._criar_tabela()
    
    def _criar_tabela(self):
        """Cria a tabela de tarefas se não existir"""
        self.conexao.execute('''
            CREATE TABLE IF NOT EXISTS tarefas (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                titulo TEXT NOT NULL,
                descricao TEXT,
                usuario_id INTEGER NOT NULL,
                data_criacao TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                status TEXT DEFAULT 'pendente'
            )
        ''')
        self.conexao.commit()
    
    def criar(self, tarefa: Tarefa) -> Tarefa:
        """Cria uma nova tarefa"""
        cursor = self.conexao.execute('''
            INSERT INTO tarefas (titulo, descricao, usuario_id, status)
            VALUES (?, ?, ?, ?)
        ''', (tarefa.titulo, tarefa.descricao, tarefa.usuario_id, tarefa.status.value))
        
        tarefa.id = cursor.lastrowid
        self.conexao.commit()
        return tarefa
    
    def buscar_por_id(self, id: int) -> Optional[Tarefa]:
        """Busca tarefa por ID"""
        cursor = self.conexao.execute('''
            SELECT id, titulo, descricao, usuario_id, data_criacao, status
            FROM tarefas WHERE id = ?
        ''', (id,))
        
        resultado = cursor.fetchone()
        if resultado:
            return Tarefa(
                id=resultado[0],
                titulo=resultado[1],
                descricao=resultado[2],
                usuario_id=resultado[3],
                data_criacao=resultado[4],
                status=StatusTarefa(resultado[5])
            )
        return None
    
    def buscar_por_usuario(self, usuario_id: int) -> List[Tarefa]:
        """Busca tarefas por usuário"""
        cursor = self.conexao.execute('''
            SELECT id, titulo, descricao, usuario_id, data_criacao, status
            FROM tarefas WHERE usuario_id = ?
            ORDER BY data_criacao DESC
        ''', (usuario_id,))
        
        tarefas = []
        for linha in cursor.fetchall():
            tarefa = Tarefa(
                id=linha[0],
                titulo=linha[1],
                descricao=linha[2],
                usuario_id=linha[3],
                data_criacao=linha[4],
                status=StatusTarefa(linha[5])
            )
            tarefas.append(tarefa)
        return tarefas

class ServicoTarefas:
    """Camada de negócio - lógica de domínio"""
    
    def __init__(self, repositorio: RepositorioTarefas):
        self.repositorio = repositorio
    
    def criar_tarefa(self, titulo: str, descricao: str, usuario_id: int) -> Tarefa:
        """Cria uma nova tarefa com validações de negócio"""
        if not titulo.strip():
            raise ValueError("Título é obrigatório")
        
        if len(titulo) > 200:
            raise ValueError("Título muito longo (máximo 200 caracteres)")
        
        if usuario_id <= 0:
            raise ValueError("ID de usuário inválido")
        
        tarefa = Tarefa(
            id=None,
            titulo=titulo,
            descricao=descricao,
            usuario_id=usuario_id,
            data_criacao=datetime.now()
        )
        
        return self.repositorio.criar(tarefa)
    
    def atualizar_status(self, tarefa_id: int, novo_status: StatusTarefa) -> bool:
        """Atualiza o status de uma tarefa"""
        tarefa = self.repositorio.buscar_por_id(tarefa_id)
        if not tarefa:
            raise ValueError("Tarefa não encontrada")
        
        # Lógica de negócio: não pode concluir uma tarefa já concluída
        if tarefa.status == StatusTarefa.CONCLUIDA and novo_status == StatusTarefa.CONCLUIDA:
            return False  # Não há mudança
        
        # Atualizar status (isso seria feito diretamente no repositório em um sistema real)
        # Para este exemplo, vamos apenas retornar sucesso
        return True

# 3. Testes automatizados
import unittest
from unittest.mock import Mock

class TesteServicoTarefas(unittest.TestCase):
    
    def setUp(self):
        """Configuração antes de cada teste"""
        self.repositorio_mock = Mock(spec=RepositorioTarefas)
        self.servico = ServicoTarefas(self.repositorio_mock)
    
    def test_criar_tarefa_com_dados_validos(self):
        """Testa criação de tarefa com dados válidos"""
        tarefa_mock = Tarefa(
            id=1,
            titulo="Teste",
            descricao="Descrição de teste",
            usuario_id=1,
            data_criacao=datetime.now()
        )
        self.repositorio_mock.criar.return_value = tarefa_mock
        
        tarefa = self.servico.criar_tarefa("Teste", "Descrição de teste", 1)
        
        self.assertEqual(tarefa.titulo, "Teste")
        self.repositorio_mock.criar.assert_called_once()
    
    def test_criar_tarefa_titulo_vazio(self):
        """Testa criação de tarefa com título vazio (deve lançar exceção)"""
        with self.assertRaises(ValueError):
            self.servico.criar_tarefa("", "Descrição", 1)
    
    def test_atualizar_status_tarefa_nao_encontrada(self):
        """Testa atualização de status de tarefa inexistente"""
        self.repositorio_mock.buscar_por_id.return_value = None
        
        with self.assertRaises(ValueError):
            self.servico.atualizar_status(999, StatusTarefa.CONCLUIDA)

# 4. Implementação da API (exemplo com Flask)
from flask import Flask, request, jsonify

app = Flask(__name__)

# Configuração do banco de dados
conexao_db = sqlite3.connect(':memory:')  # Para exemplo, usar arquivo real em produção
repositorio = RepositorioTarefas(conexao_db)
servico = ServicoTarefas(repositorio)

@app.route('/tarefas', methods=['POST'])
def criar_tarefa():
    """Endpoint para criar nova tarefa"""
    dados = request.get_json()
    
    try:
        tarefa = servico.criar_tarefa(
            dados['titulo'],
            dados.get('descricao', ''),
            dados['usuario_id']
        )
        return jsonify({
            'id': tarefa.id,
            'titulo': tarefa.titulo,
            'descricao': tarefa.descricao,
            'usuario_id': tarefa.usuario_id,
            'status': tarefa.status.value,
            'data_criacao': tarefa.data_criacao.isoformat()
        }), 201
    except ValueError as e:
        return jsonify({'erro': str(e)}), 400

@app.route('/tarefas/<int:tarefa_id>', methods=['GET'])
def obter_tarefa(tarefa_id):
    """Endpoint para obter tarefa por ID"""
    tarefa = repositorio.buscar_por_id(tarefa_id)
    if tarefa:
        return jsonify({
            'id': tarefa.id,
            'titulo': tarefa.titulo,
            'descricao': tarefa.descricao,
            'usuario_id': tarefa.usuario_id,
            'status': tarefa.status.value,
            'data_criacao': tarefa.data_criacao
        })
    return jsonify({'erro': 'Tarefa não encontrada'}), 404

if __name__ == '__main__':
    app.run(debug=True)