# Confirm Dialog

Um serviço para exibir dialogs de confirmação padronizados com ações de aceitar/rejeitar.

## Features

- Dialog de confirmação pré-configurado com layout padronizado
- Suporte a botões de aceitar e rejeitar (opcional)
- Callbacks personalizáveis para ações de confirmação e cancelamento
- Interface simplificada através do `ConfirmDialogService`
- Integração automática com o sistema de dialogs base

## Utilização

- **Serviço**: `ConfirmDialogService`

### Import

```typescript
import { ConfirmDialogService, ConfirmDialog } from '@seniorsistemas/angular-components/confirm-dialog';

@Component({
    /* ... */
})
export class MyComponent {
    constructor(private confirmDialogService: ConfirmDialogService) {}
    /* ... */
}
```

## Exemplo de utilização

### Uso básico

```typescript
export class MyComponent {
    constructor(private confirmDialogService: ConfirmDialogService) {}

    deleteItem() {
        const confirmDialog: ConfirmDialog = {
            header: 'Confirmar Exclusão',
            message: 'Tem certeza que deseja excluir este item? Esta ação não pode ser desfeita.',
            acceptLabel: 'Excluir',
            rejectLabel: 'Cancelar',
            accept: () => {
                // Lógica de exclusão
                console.log('Item excluído!');
                this.performDelete();
            },
            reject: () => {
                // Lógica de cancelamento (opcional)
                console.log('Exclusão cancelada');
            },
        };

        this.confirmDialogService.confirm(confirmDialog);
    }

    private performDelete() {
        // Implementação da exclusão
    }
}
```

### Sem botão de rejeição

```typescript
export class MyComponent {
    constructor(private confirmDialogService: ConfirmDialogService) {}

    showInfo() {
        const confirmDialog: ConfirmDialog = {
            header: 'Informação',
            message: 'Operação realizada com sucesso!',
            acceptLabel: 'OK',
            accept: () => {
                console.log('Usuário confirmou a informação');
            },
            // rejectLabel e reject são opcionais
        };

        this.confirmDialogService.confirm(confirmDialog);
    }
}
```

### Exemplo com ações assíncronas

```typescript
export class MyComponent {
    constructor(
        private confirmDialogService: ConfirmDialogService,
        private dataService: DataService,
    ) {}

    async saveChanges() {
        const confirmDialog: ConfirmDialog = {
            header: 'Salvar Alterações',
            message: 'Deseja salvar as alterações realizadas?',
            acceptLabel: 'Salvar',
            rejectLabel: 'Descartar',
            accept: async () => {
                try {
                    await this.dataService.save();
                    this.showSuccessMessage();
                } catch (error) {
                    this.showErrorMessage();
                }
            },
            reject: () => {
                this.discardChanges();
            },
        };

        this.confirmDialogService.confirm(confirmDialog);
    }
}
```

## API

### ConfirmDialogService

#### confirm(confirmDialog: ConfirmDialog): void

Exibe um dialog de confirmação com as configurações especificadas.

**Parâmetros:**

- `confirmDialog`: Objeto com as configurações do dialog

### ConfirmDialog

| Nome            | Tipo         | Obrigatório | Descrição                                                                      |
| :-------------- | :----------- | :---------- | :----------------------------------------------------------------------------- |
| **header**      | string       | Sim         | Título do dialog exibido no cabeçalho                                          |
| **message**     | string       | Sim         | Mensagem principal do dialog                                                   |
| **acceptLabel** | string       | Sim         | Texto do botão de confirmação                                                  |
| **rejectLabel** | string       | Não         | Texto do botão de cancelamento (se não informado, só exibe o botão de aceitar) |
| **accept**      | VoidFunction | Sim         | Função executada quando o usuário confirma                                     |
| **reject**      | VoidFunction | Não         | Função executada quando o usuário cancela ou fecha o dialog                    |

## Comportamento

### Fluxo de execução

1. **Confirmação**: Quando o usuário clica no botão de aceitar, a função `accept()` é executada
2. **Cancelamento**: Quando o usuário:
    - Clica no botão de rejeitar (se presente)
    - Clica fora do dialog
    - Pressiona a tecla ESC
    - Clica no X para fechar

    A função `reject()` é executada (se fornecida)

### Estados do dialog

- **Aceito**: `accept()` é chamada e o dialog é fechado
- **Rejeitado**: `reject()` é chamada (se fornecida) e o dialog é fechado
- **Fechado sem ação**: Se apenas `accept()` for fornecida e o usuário fechar o dialog sem confirmar, nenhuma função é executada

## Exemplos de casos de uso

### Confirmação de exclusão

```typescript
confirmDelete(itemId: string) {
   this.confirmDialogService.confirm({
      header: 'Confirmar Exclusão',
      message: `Tem certeza que deseja excluir o item ${itemId}?`,
      acceptLabel: 'Sim, excluir',
      rejectLabel: 'Cancelar',
      accept: () => this.deleteItem(itemId),
      reject: () => console.log('Exclusão cancelada')
   });
}
```

### Confirmação de navegação

```typescript
confirmNavigation() {
   this.confirmDialogService.confirm({
      header: 'Alterações não salvas',
      message: 'Você tem alterações não salvas. Deseja sair mesmo assim?',
      acceptLabel: 'Sair sem salvar',
      rejectLabel: 'Continuar editando',
      accept: () => this.router.navigate(['/home']),
      reject: () => console.log('Permanecendo na página')
   });
}
```

### Notificação simples

```typescript
showSuccessNotification() {
   this.confirmDialogService.confirm({
      header: 'Sucesso',
      message: 'Operação realizada com sucesso!',
      acceptLabel: 'OK',
      accept: () => console.log('Notificação confirmada')
   });
}
```

### Confirmação com validação

```typescript
confirmSubmission() {
   this.confirmDialogService.confirm({
      header: 'Enviar Formulário',
      message: 'Deseja enviar o formulário? Verifique se todos os dados estão corretos.',
      acceptLabel: 'Enviar',
      rejectLabel: 'Revisar',
      accept: () => {
         if (this.validateForm()) {
            this.submitForm();
         } else {
            this.showValidationErrors();
         }
      },
      reject: () => this.focusFirstInvalidField()
   });
}
```