Initial commit

lib/application/controllers/application_controller.dart

@@ -0,0 +1,19 @@
+import 'dart:developer';
+
+import 'package:flutter/material.dart';
+import 'package:get/get.dart';
+
+class ApplicationController extends GetxController {
+  IconData getThemeIcon() => Get.isDarkMode
+      ? Icons.light_mode
+      : Icons.dark_mode;
+
+  void toggleTheme() {
+    Get.changeThemeMode(
+        Get.isDarkMode
+            ? ThemeMode.light
+            : ThemeMode.dark
+    );
+    update();
+  }
+}

lib/application/controllers/home_controller.dart

@@ -0,0 +1,5 @@
+import 'package:get/get.dart';
+
+class HomeController extends GetxController {
+
+}

lib/application/controllers/schedule_controller.dart

@@ -0,0 +1,14 @@
+import 'package:get/get.dart';
+import 'package:reverse_nn/application/services/schedule.dart';
+
+class ScheduleController extends GetxController {
+  Rx<Map<String, dynamic>?> currentSchedule = null.obs;
+
+  @override void onReady() {
+    super.onReady();
+    ScheduleService().getCurrentStatus().then((currentSchedule) {
+      this.currentSchedule = currentSchedule.obs;
+      update();
+    });
+  }
+}

lib/application/services/schedule.dart

@@ -0,0 +1,132 @@
+import 'dart:core';
+import 'dart:convert';
+import 'dart:developer';
+import 'package:intl/intl.dart' show DateFormat;
+
+import 'package:flutter/services.dart';
+
+class ScheduleService {
+  static const Duration dayOffset = Duration(hours: 4);
+
+  Future<Map<String, dynamic>> getSchema() async {
+    final source = await rootBundle
+        .loadString('assets/schedule.json');
+    return jsonDecode(source);
+  }
+
+  Future<Map<String, dynamic>?> getRule(DateTime day) async {
+    final Map<String, dynamic> schema = await getSchema();
+    if(!schema.containsKey('rules')) return null;
+
+    for(final Map<String, dynamic> rule in (schema['rules'] as List<dynamic>)) {
+      final DateTime after = DateTime.parse(rule['after']);
+      final DateTime? before = rule['before'] != null
+        ? DateTime.parse(rule['before'])
+        : null;
+
+      if(day.isAfter(after) && (before == null || day.isBefore(before)))
+      { return rule; }
+    }
+
+    return null;
+  }
+
+  Future<Map<String, String>?> getDataset(DateTime day) async {
+    final Map<String, dynamic>? rule = await getRule(day);
+
+    if(rule == null || !rule.containsKey('dataset')) return null;
+
+    return (rule['dataset'] as Map<String, dynamic>).map((key, value) {
+      return MapEntry(key, value.toString());
+    });
+  }
+
+  String datetimeWeekdayToDatasetKey(int weekday) {
+    switch(weekday){
+      case DateTime.monday:   return 'monday';
+      case DateTime.tuesday:  return 'tuesday';
+      case DateTime.wednesday:return 'wednesday';
+      case DateTime.thursday: return 'thursday';
+      case DateTime.friday:   return 'friday';
+      case DateTime.saturday: return 'saturday';
+      case DateTime.sunday:   return 'sunday';
+    }
+
+    return 'monday';
+  }
+
+  Future<List<Map<String, dynamic>>?> getScheduleByKey(String key) async {
+    final Map<String, dynamic> schema = await getSchema();
+    if(!schema.containsKey('schedules')) return null;
+    if(!(schema['schedules'] as Map<String, dynamic>).containsKey(key)) return null;
+
+    return (schema['schedules'][key] as List<dynamic>).map((element) {
+      return element as Map<String, dynamic>;
+    }).toList();
+  }
+
+  Future<List<Map<String, dynamic>>?> getScheduleByDate(DateTime datetime) async {
+    final datetimeStartWithOffset = datetime.copyWith(hour: 0, minute: 0, second: 0, microsecond: 0, millisecond: 0)
+      .add(dayOffset);
+
+    final DateTime usedScheduleDatetime = datetime.isAfter(datetimeStartWithOffset)
+        ? datetime
+        : datetime.copyWith().subtract(const Duration(days: 1));
+
+    final Map<String, String>? dataset = await getDataset(usedScheduleDatetime);
+    if(dataset == null) return null;
+
+    final String dayKey = DateFormat('y-M-d').format(usedScheduleDatetime);
+    final String weekdayKey = datetimeWeekdayToDatasetKey(usedScheduleDatetime.weekday);
+
+    String? scheduleKey;
+    if(dataset.containsKey(dayKey)) { scheduleKey = dataset[dayKey]; }
+    else if(dataset.containsKey(weekdayKey)) { scheduleKey = dataset[weekdayKey]; }
+
+    if(scheduleKey == null) return null;
+
+    return await getScheduleByKey(scheduleKey);
+  }
+
+  Future<Map<String, dynamic>?> getCurrentStatus() async {
+    final DateTime now = DateTime.now();
+    final List<Map<String, dynamic>>? schedule = await getScheduleByDate(now);
+    if(schedule == null) return null;
+
+    DateTime datetimeStartWithOffset = now.copyWith(hour: 0, minute: 0, second: 0, microsecond: 0, millisecond: 0)
+        .add(dayOffset);
+
+    if(now.isBefore(datetimeStartWithOffset)) {
+      datetimeStartWithOffset = datetimeStartWithOffset.subtract(const Duration(days: 1));
+    }
+
+    int durationOffset = 0;
+    for (final Map<String, dynamic> scheduleItem in schedule) {
+      final int duration = (scheduleItem['duration'] as int);
+      final DateTime start = datetimeStartWithOffset.copyWith().add(Duration(minutes: durationOffset));
+      final DateTime end = datetimeStartWithOffset.copyWith().add(Duration(minutes: durationOffset + duration));
+      durationOffset += duration;
+
+      if(now.isAfter(start) && now.isBefore(end)) {
+        return <String, dynamic>{
+          "direction": scheduleItem['direction'] as String,
+          "start": start,
+          "end": end
+        };
+      }
+    }
+
+    return null;
+
+
+
+    // final datetimeStartWithOffset = now.copyWith(hour: 0, minute: 0, second: 0, microsecond: 0, millisecond: 0)
+    //     .add(dayOffset);
+    //
+    // final DateTime usedScheduleDatetime = now.isAfter(datetimeStartWithOffset)
+    //     ? now
+    //     : now.copyWith().subtract(const Duration(days: 1));
+
+
+  }
+}