<?php

namespace Drupal\locale\Form;

use Drupal\Component\Utility\Environment;
use Drupal\Core\Form\FormBase;
use Drupal\Core\Extension\ModuleHandlerInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\language\ConfigurableLanguageManagerInterface;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\locale\LocaleDefaultOptions;
use Drupal\locale\File\LocaleFile;
use Drupal\locale\LocaleConfigBatch;
use Drupal\locale\LocaleImportBatch;
use Symfony\Component\DependencyInjection\Attribute\Autowire;

/**
 * Form constructor for the translation import screen.
 *
 * @internal
 */
class ImportForm extends FormBase {

  /**
   * Uploaded file entity.
   *
   * @var \Drupal\file\Entity\File
   */
  protected $file;

  public function __construct(
    protected ModuleHandlerInterface $moduleHandler,
    #[Autowire('language_manager')]
    protected ConfigurableLanguageManagerInterface $languageManager,
    protected LocaleImportBatch $localeImportBatch,
    protected LocaleConfigBatch $localeConfigBatch,
  ) {}

  /**
   * {@inheritdoc}
   */
  public function getFormId() {
    return 'locale_translate_import_form';
  }

  /**
   * Form constructor for the translation import screen.
   */
  public function buildForm(array $form, FormStateInterface $form_state) {
    $languages = $this->languageManager->getLanguages();

    // Initialize a language list to the ones available, including English if we
    // are to translate Drupal to English as well.
    $existing_languages = [];
    foreach ($languages as $langcode => $language) {
      if (locale_is_translatable($langcode)) {
        $existing_languages[$langcode] = $language->getName();
      }
    }

    // If we have no languages available, present the list of predefined
    // languages only. If we do have already added languages, set up two option
    // groups with the list of existing and then predefined languages.
    if (empty($existing_languages)) {
      $language_options = $this->languageManager->getStandardLanguageListWithoutConfigured();
      $default = key($language_options);
    }
    else {
      $default = key($existing_languages);
      $language_options = [
        (string) $this->t('Existing languages') => $existing_languages,
        (string) $this->t('Languages not yet added') => $this->languageManager->getStandardLanguageListWithoutConfigured(),
      ];
    }

    $validators = [
      'FileExtension' => ['extensions' => 'po'],
      'FileSizeLimit' => ['fileLimit' => (int) Environment::getUploadMaxSize()],
      'FileEncoding' => ['encodings' => ['UTF-8']],
    ];
    $form['file'] = [
      '#type' => 'file',
      '#title' => $this->t('Translation file'),
      '#description' => [
        '#theme' => 'file_upload_help',
        '#description' => $this->t('A Gettext Portable Object file.'),
        '#upload_validators' => $validators,
      ],
      '#size' => 50,
      '#upload_validators' => $validators,
      '#upload_location' => 'translations://',
      '#attributes' => ['class' => ['file-import-input']],
    ];
    $form['langcode'] = [
      '#type' => 'select',
      '#title' => $this->t('Language'),
      '#options' => $language_options,
      '#default_value' => $default,
      '#attributes' => ['class' => ['langcode-input']],
    ];

    $form['customized'] = [
      '#title' => $this->t('Treat imported strings as custom translations'),
      '#type' => 'checkbox',
    ];
    $form['overwrite_options'] = [
      '#type' => 'container',
      '#tree' => TRUE,
    ];
    $form['overwrite_options']['not_customized'] = [
      '#title' => $this->t('Overwrite non-customized translations'),
      '#type' => 'checkbox',
      '#states' => [
        'checked' => [
          ':input[name="customized"]' => ['checked' => TRUE],
        ],
      ],
    ];
    $form['overwrite_options']['customized'] = [
      '#title' => $this->t('Overwrite existing customized translations'),
      '#type' => 'checkbox',
    ];

    $form['actions'] = [
      '#type' => 'actions',
    ];
    $form['actions']['submit'] = [
      '#type' => 'submit',
      '#value' => $this->t('Import'),
    ];
    return $form;
  }

  /**
   * {@inheritdoc}
   */
  public function validateForm(array &$form, FormStateInterface $form_state) {
    $this->file = _file_save_upload_from_form($form['file'], $form_state, 0);

    // Ensure we have the file uploaded.
    if (!$this->file) {
      $form_state->setErrorByName('file', $this->t('File to import not found.'));
    }
  }

  /**
   * {@inheritdoc}
   */
  public function submitForm(array &$form, FormStateInterface $form_state) {
    // Add language, if not yet supported.
    $language = $this->languageManager->getLanguage($form_state->getValue('langcode'));
    if (empty($language)) {
      $language = ConfigurableLanguage::createFromLangcode($form_state->getValue('langcode'));
      $language->save();
      // phpcs:ignore Drupal.Semantics.FunctionT.NotLiteralString
      $this->messenger()->addStatus($this->t('The language %language has been created.', ['%language' => $this->t($language->label())]));
    }
    $options = array_merge(LocaleDefaultOptions::updateOptions(), [
      'langcode' => $form_state->getValue('langcode'),
      'overwrite_options' => $form_state->getValue('overwrite_options'),
      'customized' => $form_state->getValue('customized') ? LOCALE_CUSTOMIZED : LOCALE_NOT_CUSTOMIZED,
    ]);
    $this->moduleHandler->loadInclude('locale', 'bulk.inc');
    $file = LocaleFile::createFromPath($this->file->getFilename(), $this->file->getFileUri(), $options['langcode']);
    $batch = $this->localeImportBatch->buildBatch([$file->uri => $file], $options);
    batch_set($batch);

    // Create or update all configuration translations for this language.
    if ($batch = $this->localeConfigBatch->buildBatch($options, [$form_state->getValue('langcode')])) {
      batch_set($batch);
    }

    $form_state->setRedirect('locale.translate_page');
  }

}
