# Exemplo: Criação baseada no tipo de formato
analisador = AnalisadorFactory().criar_analisador("FASTA")
resultado = analisador.analisar_sequencia("ATCGATCG")

# Exemplo: Factory cria equipamentos especializados
factory = EquipamentoLaboratorialFactory.get_factory("genetica")
centrifuga = factory.criar_centrifuga()

# Exemplo: Construção incremental de protocolo
protocolo = (GeradorDeProtocolo()
               .com_nome_pesquisador("Dr. Ana Silva")
               .com_volume_amostra(15.5)
               .com_tipo_analise("Sequenciamento")
               .gerar())

# Exemplo: Clonagem de amostra para múltiplos testes
amostra_original = AmostraBiologica("AMOSTRA_001")
amostra_clonada = amostra_original.clonar()

# Exemplo: Acesso único ao gerenciador de recursos
gerenciador = GerenciadorRecursos.get_instancia()
recurso = gerenciador.obter_recurso("Microscopio")

# Exemplo: Instâncias nomeadas de analisadores
analisador1 = MultitonFactory.get_instancia("RAPIDO")
analisador2 = MultitonFactory.get_instancia("PRECISO")

# Exemplo: Reutilização de equipamentos escassos
equipamento = pool.adquirir_equipamento()
# ... uso do equipamento ...
pool.liberar_equipamento(equipamento)

# Exemplo: Adapter unificado para diferentes formatos
from patterns.estruturais.adapter import FabricaAdapters

factory = FabricaAdapters()
adapter = factory.criar_adapter("UNIFICADO")

# Detecta automaticamente o formato e analisa
resultado = adapter.analisar_sequencia(">seq1\nATCGATCGATCGATCG")
print(f"Formato detectado: {resultado['formato']}")
print(f"Sequência: {resultado['sequencia']}")
print(f"Comprimento: {resultado['comprimento']}")

# Exemplo: Bridge separando análise e algoritmo
from patterns.estruturais.bridge import AnaliseSequenciamento, AlinhamentoGlobal

# Criar análise com algoritmo específico
analise = AnaliseSequenciamento(AlinhamentoGlobal())
resultado = analise.executar_analise("ATCGATCG", "referencia.fasta")

print(f"Tipo de análise: {resultado['tipo_analise']}")
print(f"Algoritmo usado: {resultado['algoritmo']}")
print(f"Score de alinhamento: {resultado['score']}")

# Exemplo: Composite para estrutura genômica
from patterns.estruturais.composite import Genoma, SequenciaNucleotidica, BaseNitrogenada

# Criar estrutura hierárquica
genoma = Genoma("Genoma Humano")
cromossomo1 = SequenciaNucleotidica("Cromossomo 1")
cromossomo1.adicionar_componente(BaseNitrogenada("A", 1000))
cromossomo1.adicionar_componente(BaseNitrogenada("T", 1001))
cromossomo1.adicionar_componente(BaseNitrogenada("C", 1002))
cromossomo1.adicionar_componente(BaseNitrogenada("G", 1003))

genoma.adicionar_componente(cromossomo1)

# Tratar uniformemente
print(f"Tamanho do genoma: {genoma.obter_tamanho()}")
print(f"Composição: {genoma.obter_composicao()}")

# Exemplo: Decorator para enriquecer análise
from patterns.estruturais.decorator import (
    AnaliseBasica, AnaliseComValidacao, AnaliseComRelatorio, AnaliseComCache
)

# Criar análise base e adicionar decoradores
analise = AnaliseBasica("Análise Genômica")
analise = AnaliseComValidacao(analise)
analise = AnaliseComRelatorio(analise)
analise = AnaliseComCache(analise)

# Executar com todas as funcionalidades
resultado = analise.executar("dados_genomicos.fasta")
print(f"Resultado: {resultado['resultado']}")
print(f"Validado: {resultado['validado']}")
print(f"Relatório gerado: {resultado['relatorio']}")
print(f"Cache usado: {resultado['cache']}")

# Exemplo: Facade simplificando sistema complexo
from patterns.estruturais.facade import SistemaBioinformaticaFacade

# Interface única para todo o processo
facade = SistemaBioinformaticaFacade()
resultado = facade.analisar_amostra_completa(
    amostra="sangue_paciente001",
    tipo_analise="genomica",
    referencia="hg38"
)

print(f"Status: {resultado['status']}")
print(f"Sequenciamento: {resultado['sequenciamento']['status']}")
print(f"Alinhamento: {resultado['alinhamento']['status']}")
print(f"Análise: {resultado['analise']['status']}")
print(f"Relatório: {resultado['relatorio']['arquivo']}")

# Exemplo: Flyweight para otimizar memória
from patterns.estruturais.flyweight import (
    DadoGeneticoFlyweightFactory, AnaliseGenomicaComFlyweight
)

factory = DadoGeneticoFlyweightFactory()

# Reutilizar dados compartilhados
proteina1 = factory.obter_flyweight_proteico("Hemoglobina", "MVHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNMIVIVLGHYKK")
proteina2 = factory.obter_flyweight_proteico("Hemoglobina", "MVHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLSTPDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDPENFRLLGNMIVIVLGHYKK")

# Mesmo objeto compartilhado
print(f"Mesmo objeto: {proteina1 is proteina2}")

# Análise com contexto extrínseco
analise = AnaliseGenomicaComFlyweight()
resultado1 = analise.analisar_com_contexto(proteina1, {"paciente": "001", "data": "2023-01-01"})
resultado2 = analise.analisar_com_contexto(proteina2, {"paciente": "002", "data": "2023-01-02"})

# Exemplo: Front Controller centralizando requisições
from patterns.estruturais.front_controller import FrontController, Request

# Criar requisição
request = Request(
    method="POST",
    path="/analise/sequenciamento",
    headers={"Authorization": "Bearer token123"},
    body={"amostra": "paciente001", "plataforma": "illumina"}
)

# Processar através do controlador frontal
controller = FrontController()
response = controller.processar_requisicao(request)

print(f"Status: {response.status_code}")
print(f"Resultado: {response.body}")
print(f"Headers: {response.headers}")

# Exemplo: Proxy controlando acesso ao banco de dados
from patterns.estruturais.proxy import BancoDadosGeneticosProxy

# Criar proxy com controle de acesso
banco_proxy = BancoDadosGeneticosProxy()

# Tentar acesso sem permissão
try:
    resultado = banco_proxy.buscar_sequencia("BRCA1", "usuario_sem_permissao")
except PermissionError as e:
    print(f"Erro de acesso: {e}")

# Acesso com permissão
resultado = banco_proxy.buscar_sequencia("BRCA1", "pesquisador_autorizado")
print(f"Sequência encontrada: {resultado['sequencia'][:50]}...")
print(f"Cache usado: {resultado['cache']}")
print(f"Log registrado: {resultado['log_id']}")

# Exemplo: Chain of Responsibility para processamento de sequências
from patterns.comportamentais.chain_of_responsibility import SequenceAnalysisSystem

# Criar sistema com cadeia de handlers
sistema = SequenceAnalysisSystem()

# Analisar sequência através da cadeia
resultado = sistema.analyze_sequence("ATCGATCGATCG", "DNA")
if resultado.is_valid:
    print(f"Sequência válida: {resultado.processing_steps}")
else:
    print(f"Erros: {resultado.errors}")

# Exemplo: Command para operações laboratoriais
from patterns.comportamentais.command import (
    SequenciarCommand, AlinharCommand, AnalisarCommand, InvocadorComandos
)

# Criar invocador de comandos
invocador = InvocadorComandos()

# Criar e executar comandos
cmd_sequenciar = SequenciarCommand("Amostra_001", "illumina")
cmd_alinhar = AlinharCommand("sequenciamento.fastq", "hg38")
cmd_analisar = AnalisarCommand("alinhado.bam", "variacao")

# Executar comandos
invocador.executar_comando(cmd_sequenciar)
invocador.executar_comando(cmd_alinhar)
invocador.executar_comando(cmd_analisar)

# Desfazer último comando
invocador.desfazer_ultimo_comando()

# Verificar histórico
historico = invocador.obter_historico()
print(f"Comandos executados: {len(historico)}")

# Exemplo: Iterator para resultados de análises
from patterns.comportamentais.iterator import (
    ResultadosSequenciamento, ResultadosProteomicos, TipoDado
)

# Criar coleções de resultados
resultados_seq = ResultadosSequenciamento()
resultados_prot = ResultadosProteomicos()

# Adicionar resultados
resultados_seq.adicionar(ResultadoAnalise("SEQ001", TipoDado.SEQUENCIA, {"plataforma": "illumina"}))
resultados_prot.adicionar(ResultadoAnalise("PROT001", TipoDado.PROTEINA, {"proteina": "Hemoglobina"}))

# Iterar sobre sequenciamento
iterador_seq = resultados_seq.criar_iterador()
while iterador_seq.tem_proximo():
    resultado = iterador_seq.proximo()
    print(f"Sequência: {resultado.id_resultado}")

# Iterar com filtros
iterador_prot = resultados_prot.criar_iterador()
iterador_prot.definir_filtro_peso(15000, 17000)  # Filtrar por peso molecular
while iterador_prot.tem_proximo():
    resultado = iterador_prot.proximo()
    print(f"Proteína: {resultado.dados['proteina']}")

# Exemplo: Mediator para coordenar componentes
from patterns.comportamentais.mediator import (
    CoordenadorAnalise, Sequenciador, Alinhador, Analisador
)

# Criar mediador
mediador = CoordenadorAnalise()

# Criar componentes
sequenciador = Sequenciador(mediador)
alinhador = Alinhador(mediador)
analisador = Analisador(mediador)

# Registrar componentes no mediador
mediador.registrar_componente("sequenciador", sequenciador)
mediador.registrar_componente("alinhador", alinhador)
mediador.registrar_componente("analisador", analisador)

# Iniciar processo coordenado
sequenciador.sequenciar_amostra("Amostra_001")
# O mediador coordena automaticamente o fluxo completo

# Exemplo: Memento para undo/redo em experimentos
from patterns.comportamentais.memento import ExperimentManager

# Criar gerenciador de experimentos
manager = ExperimentManager()
manager.create_experiment("EXP001", "ATCGATCG", "alignment")

# Modificar e executar análise
manager.modify_experiment(sequence="ATCGATCGATCGATCG")
manager.run_analysis()

# Desfazer alterações
manager.undo()  # Volta estado anterior
manager.redo()  # Refaz alteração

# Verificar histórico
historico = manager.get_history()
print(f"Estados salvos: {len(historico)}")

# Exemplo: Observer para notificação de análises
from patterns.comportamentais.observer import (
    Pesquisador, SistemaAlerta, AnaliseGenomica, TipoEvento
)

# Criar observadores
pesquisador1 = Pesquisador("Dr. Silva", "[email protected]", "genomica")
pesquisador2 = Pesquisador("Dra. Santos", "[email protected]", "proteomica")
sistema_alerta = SistemaAlerta("Sistema de Alertas", "alto")

# Criar análise (sujeito)
analise = AnaliseGenomica("ANALISE_001", "Análise de BRCA1")

# Registrar observadores
analise.adicionar_observador(pesquisador1)
analise.adicionar_observador(pesquisador2)
analise.adicionar_observador(sistema_alerta)

# Definir interesses
pesquisador1.definir_interesses([TipoEvento.ANALISE_CONCLUIDA])
pesquisador2.definir_interesses([TipoEvento.ANALISE_FALHOU])

# Executar análise e notificar observadores
analise.iniciar_analise()
analise.concluir_analise({"variantes": 42, "qualidade": "alta"})

# Exemplo: Strategy para diferentes algoritmos de alinhamento
from patterns.comportamentais.strategy import (
    SequenceAligner, NeedlemanWunschStrategy, SmithWatermanStrategy, BLASTStrategy
)

# Criar alinhador com estratégia inicial
aligner = SequenceAligner(NeedlemanWunschStrategy())

# Mudar estratégia dinamicamente
aligner.set_strategy(SmithWatermanStrategy())
result_local = aligner.align_sequences("ATCGATCG", "ATCGATCG")

# Comparar estratégias
benchmark = AlignmentBenchmark()
best_strategy = benchmark.get_best_strategy("ATCGATCG", "GCTAGCTA", "identity")
print(f"Melhor estratégia: {best_strategy[0]}")

# Exemplo: State para gerenciar estados de equipamento
from patterns.comportamentais.state import EquipamentoLaboratorial

# Criar equipamento
microscopio = EquipamentoLaboratorial("Microscopio_001", "Microscópio Eletrônico")

# Verificar estado inicial
status = microscopio.verificar_status()
print(f"Estado inicial: {status['estado_atual']}")

# Ligando equipamento
microscopio.ligar()

# Iniciar uso
microscopio.iniciar_uso("Dr. Silva")
print(f"Em uso por: {microscopio.usuario_atual}")

# Tentar usar por outro usuário (deve falhar)
resultado = microscopio.iniciar_uso("Dra. Santos")
print(f"Segunda tentativa: {resultado}")

# Finalizar uso
microscopio.finalizar_uso()

# Iniciar manutenção
microscopio.iniciar_manutencao("Técnico João")
print(f"Em manutenção com: {microscopio.tecnico_manutencao}")

# Exemplo: Template Method para pipelines de análise
from patterns.comportamentais.template_method import (
    PipelineGenomica, PipelineProteomica, PipelineTranscriptomica
)

# Criar pipelines específicos
pipeline_genomica = PipelineGenomica("Análise BRCA1")
pipeline_proteomica = PipelineProteomica("Análise Proteômica")
pipeline_transcriptomica = PipelineTranscriptomica("Análise de Expressão")

# Executar pipelines com estrutura comum mas implementações diferentes
dados_teste = {"amostra": "Paciente_001", "tipo": "sangue"}

resultado_genomica = pipeline_genomica.executar_analise_completa(dados_teste)
print(f"Genômica: {resultado_genomica.obter_resumo()['status']}")

resultado_proteomica = pipeline_proteomica.executar_analise_completa(dados_teste)
print(f"Proteômica: {resultado_proteomica.obter_resumo()['status']}")

resultado_transcriptomica = pipeline_transcriptomica.executar_analise_completa(dados_teste)
print(f"Transcriptômica: {resultado_transcriptomica.obter_resumo()['status']}")

# Exemplo: Visitor para análises moleculares
from patterns.comportamentais.visitor import (
    GeneProteina, GeneRegulador, GeneEstrutural, GeneHousekeeping,
    AnalisadorMolecular, OtimizadorTerapeutico
)

# Criar diferentes tipos de genes
gene_proteina = GeneProteina("BRCA1", "17", 43044295, "Proteína supressora de tumor")
gene_regulador = GeneRegulador("TP53", "17", 7579472, "ativador")
gene_estrutural = GeneEstrutural("ACTB", "7", 5524907, "Manutenção do citoesqueleto")
gene_housekeeping = GeneHousekeeping("GAPDH", "12", 6656342, "Glicólise")

# Configurar genes
gene_proteina.definir_sequencia("ATCGATCGATCGATCG")
gene_proteina.definir_expressao(2.5)
gene_proteina.adicionar_dominio("RING")
gene_proteina.adicionar_dominio("BRCT")

# Criar visitantes
analisador = AnalisadorMolecular()
otimizador = OtimizadorTerapeutico()

# Aplicar visitantes aos genes
genes = [gene_proteina, gene_regulador, gene_estrutural, gene_housekeeping]

for gene in genes:
    # Análise molecular
    resultado_analise = gene.aceitar(analisador)
    print(f"{gene.nome}: {resultado_analise['tipo']}")
    
    # Análise terapêutica
    resultado_terapeutico = gene.aceitar(otimizador)
    print(f"  Score terapêutico: {resultado_terapeutico.get('score', 0):.2f}")

# Obter alvos terapêuticos identificados
alvos = otimizador.obter_alvos_terapeuticos()
print(f"\nAlvos terapêuticos identificados: {len(alvos)}")