import 'dart:io';
import 'package:path_provider/path_provider.dart';
import 'package:rogapp/model/destination.dart';
import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';

class DatabaseHelper{
  DatabaseHelper._privateConstructor();
  static final DatabaseHelper instance = DatabaseHelper._privateConstructor();

  static Database? _database;
  Future<Database> get database async => _database ??= await _initDatabase();

  Future<Database> _initDatabase() async {
    Directory documentDirectory = await getApplicationDocumentsDirectory();
    String path = join(documentDirectory.path, 'rog.db');
    // return  await openDatabase(
    //   path,
    //   version: 1,
    //   onCreate: _onCreate,
    // );
    return openDatabase(join(await getDatabasesPath(), 'rog.db',), version: 1, onCreate: _onCreate);
  }

  Future _onCreate(Database db, int version) async {
    await db.execute('''
    CREATE TABLE destination(
      location_id INTEGER PRIMARY KEY,
      name TEXT,
      address TEXT,
      phone TEXT,
      email TEXT,
      webcontents TEXT,
      videos TEXT,
      category TEXT,
      series INTEGER,
      lat REAL, 
      lon REAL, 
      list_order INTEGER,
      photos TEXT,
      checkin_radious REAL,
      auto_checkin INTEGER,
      selected INTEGER,
      checkedin INTEGER,
      cp REAL,
      checkin_point REAL,
      buy_point REAL
    )
    ''');
  }

  Future<List<Destination>> getDestinations() async {
    Database db = await instance.database;
    var dest = await db.query('destination', orderBy: 'list_order');
    List<Destination> destList = dest.isNotEmpty ?
      dest.map((e) => Destination.fromMap(e)).toList() : [];
    print("--------- ${destList}");
    return destList;
  }

  Future<List<Destination>> getDestinationByLatLon(double lat, double lon) async {
    Database db = await instance.database;
    var dest = await db.query('destination', where: "lat = ${lat} and lon= ${lon}", orderBy: 'list_order');
    List<Destination> destList = dest.isNotEmpty
      ? dest.map((e) => Destination.fromMap(e)).toList() : [];
    return destList;
  }

  Future<int> deleteDestination(int location_id) async {
    Database db = await instance.database;
    var dest = await db.delete('destination', where: "location_id = ${location_id}");
    int ret = dest > 0 ? dest : -1;
    return ret;
  }

  Future<void> deleteAllDestinations() async {
    Database db = await instance.database;
    await db.delete('destination');
  }

  Future<bool>isAlreadyAvailable(int location_id) async{
    Database db = await instance.database;
    var dest = await db.query('destination', where: "location_id = ${location_id}");
    return dest.length > 0 ? true : false;
  }

  Future<int> insertDestination(Destination dest) async {
    Database db = await instance.database;
    int? next_order = Sqflite.firstIntValue(await db.rawQuery('SELECT MAX(list_order) FROM destination'));
    next_order = next_order==null ? 0 : next_order;
    next_order = next_order + 1;
    dest.list_order = next_order;
    int res = await db.insert(
      'destination',
      dest.toMap(),
      conflictAlgorithm: ConflictAlgorithm.replace,
    );
    print("------ database helper insert ${res}-----------::::::::");
    return res;
  }

  Future<int> updateAction(Destination destination, bool checkin)async {
    Database db = await instance.database;
    int act = checkin == false ? 0 : 1;
    Map<String, dynamic> row = {
      "checkedin": act
    };
    return await db.update(
      "destination", 
      row,
      where: 'location_id = ?',
      whereArgs: [destination.location_id]
      );
  }

  Future<void> updateOrder(Destination d, int dir)async {
    Database db = await instance.database;
    var target = await db.query('destination', where: "list_order = ${d.list_order! + dir}");
    var dest = await db.query('destination', where: "location_id = ${d.location_id}");
    if(target.isNotEmpty){

      List<Destination> target_indb = target.isNotEmpty
      ? target.map((e) => Destination.fromMap(e)).toList() : [];

      List<Destination> dest_indb = dest.isNotEmpty
      ? dest.map((e) => Destination.fromMap(e)).toList() : [];

      Map<String, dynamic> row_target = {
        "list_order": d.list_order
      };

      Map<String, dynamic> row_des = {
        "list_order": dest_indb[0].list_order
      };

      await db.update(
        "destination", 
        row_target,
        where: 'location_id = ?',
        whereArgs: [target_indb[0]!.location_id]
      );

      await db.update(
        "destination", 
        row_des,
        where: 'location_id = ?',
        whereArgs: [dest_indb[0]!.location_id]
      );
    }
  }

  // Future<int?> getPending() async{
  //   Database db = await instance.database;
  //   return await Sqflite.firstIntValue(await db.rawQuery("SELECT COUNT(*) FROM incidents"));
  // }

}