import 'dart:io';

import 'package:brick_generator/models/brick_config.dart';
import 'package:brick_generator/models/variable_string_syntax.dart';
import 'package:brick_generator/models/variable_type.dart';
import 'package:brick_generator/shell.dart';
import 'package:brick_generator/yaml_reader.dart';
import 'package:path/path.dart' as path;

// Constants
const _bricks = 'bricks';
const _brickFolderLabel = '__brick__';
const _yamlFileName = 'brick_config.yaml';

Future<void> main(List<String> arguments) async {
  try {
    if (arguments.length != 1) {
      throw ArgumentError('Please entry exemple project path');
    }

    final projectPath = arguments[0];

    // Store options from yaml file
    final configs =
        YamlReader.readYamlFile(path.join(projectPath, _yamlFileName));
    final brickConfig = BrickConfig.from(configs);
    stdout.writeln('🍺 config retrieved');

    brickConfig?.checkFormat();

    // Define paths
    final sourcePath = path.join(
      projectPath,
      brickConfig!.pathToBrickify,
    );
    final targetPath = path.join(
      _bricks,
      brickConfig.brickName,
      _brickFolderLabel,
    );
    stdout.writeln('🍺 path defined');

    // Remove previously generated files
    final targetDir = Directory(targetPath);
    if (targetDir.existsSync()) {
      await targetDir.delete(recursive: true);
    }

    // create target folder
    await Shell.mkdir(targetPath);

    // Copy project files
    await Shell.cp(sourcePath, targetPath);
    stdout.writeln('🍺 files copied');

    // Convert values to variables
    await Future.wait(
      Directory(targetPath)
          .listSync(recursive: true)
          .whereType<File>()
          .map((_) async {
        var file = _;

        var contents = await file.readAsString();

        // Transform all values in variables
        if (brickConfig.variables != null) {
          for (final variable in brickConfig.variables!) {
            if (variable?.type == VariabelType.string) {
              for (final syntax in VariableStringSyntax.values) {
                final toReplace = variable?.syntax?.getValue(syntax);
                if (toReplace != null) {
                  contents = contents.replaceAll(
                    variable!.syntax!.getValue(syntax)!,
                    '{{#${syntax.id}}}{{${variable.name}}}{{/${syntax.id}}}',
                  );
                }
              }
            }
          }
        }

        // Replace content
        file = await file.writeAsString(contents);
        stdout.writeln('🍺 variables added');

        // Rename file if needed
        final filePath = file.path;

        if (brickConfig.variables != null) {
          for (final variable in brickConfig.variables!) {
            if (variable?.type == VariabelType.string) {
              if (filePath.contains(variable!.syntax!.snakeCase!)) {
                var pathList =
                    filePath.split(Platform.pathSeparator).sublist(3);
                pathList = pathList
                    .map(
                      (segment) => segment.replaceAll(
                        variable.syntax!.snakeCase!,
                        '{{${variable.name}.snakeCase()}}',
                      ),
                    )
                    .toList();

                final newPath = path.join(
                  filePath
                      .split(Platform.pathSeparator)
                      .sublist(0, 3)
                      .join(Platform.pathSeparator),
                  pathList.join(Platform.pathSeparator),
                );

                File(newPath).createSync(recursive: true);
                file.renameSync(newPath);
                Directory(file.parent.path).deleteSync(recursive: true);
              }
            }
          }
        }
        stdout.writeln('🍺 folders and files renamed');
      }),
    );
    stdout.writeln('🍺 done');
  } catch (_) {
    stdout.writeln('❌ ${_.toString()}');
  }
}