import 'package:gamer_updater/db.dart';
import 'package:gamer_updater/utils.dart';
import 'package:http/http.dart' as http;
import 'package:dart_rss/dart_rss.dart';

class Game {
  final String name;
  final String versionRegex;
  final RegExp _internalVersionRegex;
  final String lastPlayed;
  String actualVersion;
  String lastUpdated;
  final String rssFeedUrl;

  Game({
    required this.name,
    required this.versionRegex,
    required this.lastPlayed,
    this.actualVersion = '',
    required this.rssFeedUrl,
    this.lastUpdated = '',
  }) : _internalVersionRegex = RegExp(versionRegex);

  factory Game.fromMap(Map<String, dynamic> map) {
    return Game(
      name: map['name'],
      versionRegex: map['version_regex'],
      lastPlayed: map['last_played'],
      rssFeedUrl: map['rss_feed_url'],
      actualVersion: map['actual_version'],
      lastUpdated: map['last_updated'],
    );
  }

  Future<void> updateActualVersion() async {
    final response = await http.get(Uri.parse(rssFeedUrl));
    final document = RssFeed.parse(response.body);
    final pages = document.items;
    pages.sort((a, b) {
      var lhs = parseRfc822Date(a.pubDate!);
      var rhs = parseRfc822Date(b.pubDate!);
      return rhs.compareTo(lhs);
    });
    final versions =
        pages
            .map((e) => _internalVersionRegex.firstMatch(e.title!)?.group(1))
            .toList();

    for (int i = 0; i < versions.length; i++) {
      final version = versions[i];
      final page = pages[i];
      if (version != null) {
        actualVersion = version;
        lastUpdated = parseRfc822Date(page.pubDate!).toIso8601String();
        break;
      }
    }
  }
}

class GameRepository {
  static Future<Game> upsert(Game game) async {
    final db = await DB.db;
    await db.rawInsert(
      '''
INSERT INTO games
(name, actual_version, last_played, rss_feed_url, version_regex, last_updated)
VALUES
(?, ?, ?, ?, ?, ?)
ON CONFLICT(name) DO UPDATE SET
actual_version = excluded.actual_version,
last_played = excluded.last_played,
rss_feed_url = excluded.rss_feed_url,
version_regex = excluded.version_regex,
last_updated = excluded.last_updated
''',
      [
        game.name,
        game.actualVersion,
        game.lastPlayed,
        game.rssFeedUrl,
        game.versionRegex,
        game.lastUpdated,
      ],
    );
    return game;
  }

  static Future<List<Game>> getAll() async {
    final db = DB.db;
    final games = await db.rawQuery(
      'SELECT name, actual_version, last_played, rss_feed_url, version_regex, last_updated FROM games',
    );
    return games.map((e) => Game.fromMap(e)).toList();
  }
}

//CREATE TABLE IF NOT EXISTS games (
//  id INTEGER PRIMARY KEY AUTOINCREMENT,
//  name TEXT NOT NULL,
//  actual_version TEXT NOT NULL,
//  last_played TEXT NOT NULL,
//  rss_feed_url TEXT NOT NULL,
//  version_regex TEXT NOT NULL,
//  last_updated TEXT NOT NULL
//);
//CREATE INDEX IF NOT EXISTS idx_games_name ON games (name);