tasks/lib/pages/task_edit_page.dart

import 'package:flutter/material.dart';

import '../model/callback_models/create_task_request.dart';
import '../model/extensions/controller_context.dart';
import '../model/task.dart';
import '../service/task_controller.dart';
import '../service/tools.dart';
import '../service/validators.dart';

class TaskEditPage extends StatefulWidget {
  static const routeName = '/edit';
  const TaskEditPage({super.key});

  @override
  State<TaskEditPage> createState() => _TaskEditPageState();
}

class _TaskEditPageState extends State<TaskEditPage> {
  Task? task;
  bool isInitialized = true;
  final titleController = TextEditingController();
  final descriptionController = TextEditingController();
  final categoryController = TextEditingController();
  final urlController = TextEditingController();
  final dueDateController = TextEditingController();
  final dueTimeController = TextEditingController();
  late String pageTitle;
  final dueDateFocusNode = FocusNode();
  final dueTimeFocusNode = FocusNode();
  final categoryFocusNode = FocusNode();

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    task = ModalRoute.of(context)!.settings.arguments as Task?;
    if (task != null && !isInitialized) {
      titleController.text = task!.title;
      descriptionController.text = task!.description;
      categoryController.text = task!.category;
      urlController.text = task!.url;
      dueDateController.text = task!.due != null
          ? getIsoDateString(task!.due!)
          : '';
      dueTimeController.text = task!.due != null
          ? TimeOfDay.fromDateTime(task!.due!).format(context)
          : '';
      isInitialized = true;
    }
    pageTitle = task?.title ?? 'CreateTask';
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(pageTitle),
        actions: [
          if (task != null)
            IconButton(
              onPressed: () {
                context.controller<TaskController>().deleteTask(task!);
                Navigator.of(context).pop();
              },
              icon: Icon(Icons.delete),
            ),
        ],
      ),
      body: Form(
        autovalidateMode: AutovalidateMode.onUnfocus,
        child: Padding(
          padding: EdgeInsets.symmetric(
            horizontal: MediaQuery.of(context).size.width * 0.05,
          ),
          child: Column(
            children: [
              TextFormField(
                autofocus: true,
                controller: titleController,
                decoration: InputDecoration(label: Text('Title')),
                keyboardType: TextInputType.text,
                textInputAction: TextInputAction.next,
              ),
              TextFormField(
                controller: descriptionController,
                decoration: InputDecoration(label: Text('Description')),
                keyboardType: TextInputType.multiline,
                textInputAction: TextInputAction.newline,
                minLines: 3,
                maxLines: 10,
              ),
              TextFormField(
                focusNode: dueDateFocusNode,
                controller: dueDateController,
                onFieldSubmitted: (_) => dueDateFocusNode.nextFocus(),
                decoration: InputDecoration(
                  label: Text('Due Date'),
                  suffix: IconButton(
                    onPressed: () async {
                      final result = await onOpenCalendarPickerPressed();
                      if (result != null) {
                        dueDateController.text = getIsoDateString(result);
                        dueTimeFocusNode.requestFocus();
                      }
                    },
                    icon: Icon(Icons.calendar_month),
                  ),
                ),
                validator: dateTimeValidator,
                keyboardType: TextInputType.datetime,
                textInputAction: TextInputAction.next,
              ),
              TextFormField(
                focusNode: dueTimeFocusNode,
                onFieldSubmitted: (_) => dueTimeFocusNode.nextFocus(),
                controller: dueTimeController,
                enabled: DateTime.tryParse(dueDateController.text) != null
                    ? true
                    : false,
                decoration: InputDecoration(
                  label: Text('Due Time'),
                  suffix: IconButton(
                    onPressed: () async {
                      final result = await onOpenTimePickerPressed();
                      if (result != null && context.mounted) {
                        dueTimeController.text = result.format(context);
                        categoryFocusNode.requestFocus();
                      }
                    },
                    icon: Icon(Icons.schedule),
                  ),
                ),
                validator: timeValidator,
                keyboardType: TextInputType.text,
                textInputAction: TextInputAction.next,
              ),
              TextFormField(
                focusNode: categoryFocusNode,
                controller: categoryController,
                decoration: InputDecoration(label: Text('Category')),
                keyboardType: TextInputType.text,
                textInputAction: TextInputAction.next,
              ),
              TextFormField(
                controller: urlController,
                decoration: InputDecoration(label: Text('Url')),
                keyboardType: TextInputType.text,
                textInputAction: TextInputAction.next,
              ),
            ],
          ),
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: onSavePressed,
        child: Icon(Icons.save),
      ),
    );
  }

  Future<DateTime?> onOpenCalendarPickerPressed() {
    return showDialog<DateTime?>(
      context: context,
      builder: (context) => DatePickerDialog(
        firstDate: DateTime(DateTime.now().year - 100),
        lastDate: DateTime(DateTime.now().year + 100),
        initialDate:
            DateTime.tryParse(dueDateController.text) ?? DateTime.now(),
      ),
    );
  }

  Future<TimeOfDay?> onOpenTimePickerPressed() {
    return showDialog<TimeOfDay?>(
      context: context,
      builder: (context) =>
          TimePickerDialog(initialTime: TimeOfDay(hour: 0, minute: 0)),
    );
  }

  void onSavePressed() {
    Navigator.of(context).pop(
      CreateTaskRequest(
        title: titleController.text,
        description: descriptionController.text,
        start: null,
        due: DateTime.tryParse(dueDateController.text),
        isCompleted: false,
        category: categoryController.text,
        subtasks: [],
        alarms: [],
        location: null,
        url: urlController.text,
      ),
    );
  }
}