define('AVAILABLE_LANGUAGES', ['en', 'fr']);
define('DEFAULT_LANGUAGE', 'en');

$interceptors = [
'language' => 'before'
];
define('INTERCEPTORS', $interceptors);

'fr/(:any)/(:any)' => '$1/$2',
'en/(:any)/(:any)' => '$1/$2'

# Language Module for Trongate v2

The **Language module** provides a simple and extensible system for multi-language support in Trongate v2 that includes:

- Language detection from URL, cookie, or default.
- Dynamic loading of language files.
- Global `_l()` helper for translating strings.
- Interceptor for early language detection before routing.

---

## Folder Structure

Here's a recommended folder layout for the Language module within your Trongate app:

```
app/
config/
config.php
custom_routing.php
languages/
en.php
fr.php
modules/
language/
Language.php
language_helper.php
modules/
projects/
Projects.php
views/
edit.php
```

- app/config/: Configuration files for languages and routing.
- app/languages/: Translation files for each supported language.
- app/modules/language/: Contains the Language module and helper.
- app/modules/projects/: Inspired example module by [PartialShawn](https://github.com/PartialShawn/projects-manager-trongate) using the language system.

---

## 1. Configuration

### **config.php**

Define the available languages and default language:

```php
define('AVAILABLE_LANGUAGES', ['en', 'fr']);
define('DEFAULT_LANGUAGE', 'en');

// Interceptors (run before routing)
$interceptors = [
'language' => 'before'
];
define('INTERCEPTORS', $interceptors);
```

- **AVAILABLE_LANGUAGES**: Array of language codes that your site supports.
- **DEFAULT_LANGUAGE**: Fallback language if none is detected.
- **INTERCEPTORS**: Runs the `before()` method of the `Language` module early in the request lifecycle to detect/ set the language.

---

### **custom_routing.php**

For language-based URLs, add routes to strip the language segment for routing:

```php
$routes = [
'tg-admin' => 'trongate_administrators/login',
'tg-admin/submit_login' => 'trongate_administrators/submit_login',
'fr/(:any)/(:any)' => '$1/$2',
'en/(:any)/(:any)' => '$1/$2'
];
define('CUSTOM_ROUTES', $routes);
```

- This allows URLs like `http://localhost/{app_name}/fr/projects/edit` to route to `projects/edit`.
- The interceptor will detect `fr` as the current language.

---

## 2. Language Files

Store language files in `languages/` within your **app folder**:

```
languages/
en.php
fr.php
```

Each file should return an associative array of translation keys:

`en.php`

```php
<?php
return [
'create_project' => 'Create Project',
'edit_project' => 'Edit Project',
'delete_project' => 'Delete Project'
];
```

`fr.php`

```php
<?php
return [
'create_project' => 'Créer un projet',
'update_project' => 'Mettre à jour le projet',
'delete_project' => 'Supprimer le projet',
'submit' => 'Envoyer'
];
```

- The keys are used in controllers/views.
- Add new languages by creating additional files (e.g., `es.php` for Spanish) and adding the code to `AVAILABLE_LANGUAGES` or letting it be auto-detected if you implement dynamic loading.

---

## 3. Usage in Controllers

Inject the language module into your controller or use the global `_l()` helper:

```php
class Projects extends Trongate {

public function edit(): void {
// Option 1: Use the Language module directly
$project_name_label = $this->language->get('edit_project');

// Option 2: Use global helper
$project_name_label = _l('edit_project');

$data['label'] = $project_name_label;
$this->view('projects/edit', $data);
}
}
```

- `$this->language->get('key')` reads the string for the current language.
- `_l('key')` is a global shortcut provided by the module’s helper.

---

## 4. Usage in Views

```php
<h1><?= _l('create_project') ?></h1>

<form method="post">
<label><?= _l('project_name') ?></label>
<input type="text" name="name" />
</form>
```

- All view files can use `_l()` without instantiating the module.
- Strings fallback to the key if no translation is found.

---

## 5. Interceptor Behavior

The `before()` method of the Language module:

1. Reads the first URL segment (e.g., `fr` or `en`).
2. Sets `$_GET['lang']` for use throughout the request.
3. Falls back to:
- Cookie `site_lang` if present.
- `DEFAULT_LANGUAGE` if neither URL nor cookie is valid.

---

## 6. Optional: Manually Switching Languages

```php
$this->language->set('fr'); // Force French
```

- Updates the current language dynamically.
- Useful for language switcher forms.

---

## 7. Notes

- No changes are needed in `engine/ignition.php/get_segments()` or other core files.
- The module works fully via the interceptor and the helper.
- Adding a new language requires:
1. Creating a `languages/xx.php` file.
2. Adding the language code to `AVAILABLE_LANGUAGES` (or using dynamic detection).
3. Adding a new custom route if you are using a URL

---

This setup provides a **fully modular, multilingual architecture** compatible with Trongate v2’s philosophy of modular MVC and zero core changes.

DaFa

<?php

/**
* Language Module for Trongate v2
*
* Handles:
* - Language detection via URL, cookie, or default
* - Loading language files dynamically
* - Providing translated strings via get() or the global _l() helper
* - Interceptor for early language detection before routing
*/

class Language extends Trongate {

/** @var array<string,array<string,string>> Cache of loaded languages */
private static array $loaded_languages = [];

/** @var string Current language code */
private static string $current_language = '';

/**
* Constructor
*
* @param string|null $module_name Optional module name
*/
public function __construct(?string $module_name = null) {
parent::__construct($module_name);

// Include the helper (makes _l() available globally)
require_once __DIR__ . '/language_helper.php';

// Detect language based on $_GET, cookie, or fallback
$this->detect_language();
}

/**
* Detect language from $_GET['lang'], cookie, or default
*
* @return void
*/
private function detect_language(): void {
if (self::$current_language !== '') {
return;
}

// Check URL parameter first
if (isset($_GET['lang']) && file_exists(APPPATH . "languages/{$_GET['lang']}.php")) {
self::$current_language = strtolower($_GET['lang']);
return;
}

// Fallback to cookie
if (isset($_COOKIE['site_lang']) && file_exists(APPPATH . "languages/{$_COOKIE['site_lang']}.php")) {
self::$current_language = strtolower($_COOKIE['site_lang']);
return;
}

// Default language
self::$current_language = DEFAULT_LANGUAGE;
}

/**
* Load the current language file (if not already loaded)
*
* @return void
* @throws Exception If the language file does not exist
*/
private function load(): void {
if (!isset(self::$loaded_languages[self::$current_language])) {
$lang_file = APPPATH . "languages/" . self::$current_language . ".php";

if (!file_exists($lang_file)) {
throw new Exception("Language file not found: {$lang_file}");
}

self::$loaded_languages[self::$current_language] = include $lang_file;
}
}

/**
* Get a translated string by key
*
* @param string $key The translation key
* @return string Translated string or key if not found
*/
public function get(string $key): string {
$this->load();
return self::$loaded_languages[self::$current_language][$key] ?? $key;
}

/**
* Get the current language code
*
* @return string
*/
public function current(): string {
return self::$current_language;
}

/**
* Set the current language and persist it to the session cookie
*
* @param string $lang_code
* @return void
*/
public function set(string $lang_code): void {
self::$current_language = strtolower($lang_code);
$this->write_cookie(self::$current_language);
}

/**
* Write the language choice to a long-lived cookie so it persists
* across requests that do not carry a language URL prefix.
*
* @param string $lang
* @return void
*/
private function write_cookie(string $lang): void {
setcookie(
'site_lang',
$lang,
[
'expires' => time() + (86400 * 30), // 30 days
'path' => '/',
'secure' => isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on',
'httponly' => true,
'samesite' => 'Lax',
]
);
}

/**
* POST endpoint: switch the active language.
*
* Expects $_POST['lang'] to be a valid language code.
* Sets the site_lang cookie and redirects back to the
* referring page (or site root if no referrer).
*
* @return void
*/
public function switch_lang(): void {
// Validate CSRF token injected by form_close()
$posted_token = $_POST['csrf_token'] ?? '';
$session_token = $_SESSION['csrf_token'] ?? '';

if (!hash_equals($session_token, $posted_token)) {
// Invalid or missing token — silently redirect home
header('Location: ' . BASE_URL);
exit;
}

// Token is consumed; regenerate on next form render
unset($_SESSION['csrf_token']);

$lang = strtolower(trim($_POST['lang'] ?? ''));

if (in_array($lang, AVAILABLE_LANGUAGES, true)) {
$this->set($lang);
}

// Redirect back to where the user came from
$redirect = $_SERVER['HTTP_REFERER'] ?? BASE_URL;
header('Location: ' . $redirect);
exit;
}

/**
* Language Interceptor
*
* Detects language from the original URL before routing
* and sets $_GET['lang'] for use.
*
* @return void
*/
public function before(): void {
// Get the original URL path (without domain)
$path = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$path = trim($path, '/'); // e.g., "fr/projects/edit"

// Explode into segments
$url_segments = explode('/', $path);

// Language segment is expected as the first segment after the app folder
$lang_segment = $url_segments[1] ?? null;

if (in_array($lang_segment, AVAILABLE_LANGUAGES, true)) {
// Language found in URL — use it and persist to cookie
$_GET['lang'] = $lang_segment;
$this->set($lang_segment);
} elseif (
isset($_COOKIE['site_lang']) &&
in_array($_COOKIE['site_lang'], AVAILABLE_LANGUAGES, true)
) {
// No URL prefix — honour the persisted cookie preference
$_GET['lang'] = $_COOKIE['site_lang'];
self::$current_language = $_COOKIE['site_lang']; // skip write_cookie; cookie already set
} else {
// No URL prefix and no valid cookie — fall back to default and set cookie
$_GET['lang'] = DEFAULT_LANGUAGE;
$this->set(DEFAULT_LANGUAGE);
}
}
}

<?php
if (!function_exists('_l')) {
/**
* Get localised string
*/
function _l(string $key): string {
static $language_module = null;

if ($language_module === null) {
// Automatically lazy-load the Language module
$language_module = new Language('language');
}

return $language_module->get($key);
}
}