import 'package:flutter/foundation.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../models/programmer_day_sheet.model.dart';
import '../models/programmer_day_sheet_event.model.dart';
import '../utils/app_time.dart';
import '../utils/programmer_daily_time.dart';
import 'notifications_provider.dart';
import 'profile_provider.dart';
import 'supabase_provider.dart';

// ---------------------------------------------------------------------------
// Shared types
// ---------------------------------------------------------------------------

/// Callback type for sending push notifications.
typedef PushFn = Future<void> Function({
  required List<String> userIds,
  required String title,
  required String body,
  Map<String, dynamic>? data,
});

// ---------------------------------------------------------------------------
// Error types
// ---------------------------------------------------------------------------

enum DaySheetError {
  alreadyReviewed,
  alreadySubmitted,
  notAuthorized,
  remarksRequired,
  bodyRequired,
  workDateLocked,
  invalidSnapshot,
  unknown,
}

class DaySheetActionException implements Exception {
  const DaySheetActionException(this.code);

  final DaySheetError code;

  String get message {
    switch (code) {
      case DaySheetError.alreadyReviewed:
        return 'This sheet was already reviewed.';
      case DaySheetError.alreadySubmitted:
        return 'This day sheet was already submitted.';
      case DaySheetError.notAuthorized:
        return 'You are not allowed to do that.';
      case DaySheetError.remarksRequired:
        return 'Remarks are required to disapprove.';
      case DaySheetError.bodyRequired:
        return 'Please write a justification.';
      case DaySheetError.workDateLocked:
        return 'That day is locked — you can only add entries to pending or disapproved days.';
      case DaySheetError.invalidSnapshot:
        return 'Could not approve: the sheet data was invalid.';
      case DaySheetError.unknown:
        return 'Something went wrong. Please try again.';
    }
  }

  @override
  String toString() => 'DaySheetActionException(${code.name}): $message';
}

/// Maps an RPC error to a [DaySheetError] by substring-matching the lowercased
/// error string against the known database error codes.
DaySheetError mapDaySheetError(Object error) {
  final s = error.toString().toLowerCase();
  if (s.contains('not_authorized')) return DaySheetError.notAuthorized;
  if (s.contains('already_reviewed')) return DaySheetError.alreadyReviewed;
  if (s.contains('already_submitted')) return DaySheetError.alreadySubmitted;
  if (s.contains('remarks_required')) return DaySheetError.remarksRequired;
  if (s.contains('body_required')) return DaySheetError.bodyRequired;
  if (s.contains('work_date_locked')) return DaySheetError.workDateLocked;
  if (s.contains('invalid_snapshot')) return DaySheetError.invalidSnapshot;
  return DaySheetError.unknown;
}

// ---------------------------------------------------------------------------
// Result type
// ---------------------------------------------------------------------------

class BulkApproveResult {
  const BulkApproveResult({
    required this.approvedIds,
    required this.skippedIds,
  });

  final List<String> approvedIds;
  final List<String> skippedIds;
}

// ---------------------------------------------------------------------------
// Controller
// ---------------------------------------------------------------------------

class DaySheetsController {
  DaySheetsController(this._client, {required PushFn push}) : _push = push;

  final dynamic _client;
  final PushFn _push;

  // -------------------------------------------------------------------------
  // Submit
  // -------------------------------------------------------------------------

  Future<String> submit(DateTime dayKey) async {
    try {
      final dateStr = formatDayKey(dayKey);
      final result = await _client.rpc(
        'submit_day_sheet',
        params: {'p_date': dateStr},
      ) as Map<String, dynamic>;

      final sheetId = result['sheet_id'] as String;
      final workDate = parseDayKey(result['work_date'] as String);
      final programmerName = result['programmer_name'] as String;
      final notifyUserIds =
          List<String>.from(result['notify_user_ids'] as List? ?? []);

      if (notifyUserIds.isNotEmpty) {
        try {
          await _push(
            userIds: notifyUserIds,
            title: 'Day sheet submitted',
            body:
                '$programmerName submitted their day sheet for ${AppTime.formatDate(workDate)}',
            data: {
              'type': 'day_sheet_submitted',
              'navigate_to': '/programmer-tasks/day-sheets/$sheetId',
            },
          );
        } catch (e) {
          debugPrint('DaySheetsController.submit push error: $e');
        }
      }

      return sheetId;
    } catch (e) {
      if (e is DaySheetActionException) rethrow;
      throw DaySheetActionException(mapDaySheetError(e));
    }
  }

  // -------------------------------------------------------------------------
  // Disapprove
  // -------------------------------------------------------------------------

  Future<void> disapprove({
    required String sheetId,
    required String remarks,
    required List<String> flaggedTaskIds,
  }) async {
    if (remarks.trim().isEmpty) {
      throw DaySheetActionException(DaySheetError.remarksRequired);
    }
    try {
      final result = await _client.rpc(
        'disapprove_day_sheet',
        params: {
          'p_sheet': sheetId,
          'p_remarks': remarks.trim(),
          'p_flagged_task_ids': flaggedTaskIds,
        },
      );

      if (result is Map<String, dynamic>) {
        final programmerId = result['programmer_id'] as String?;
        final rawDate = result['work_date'] as String?;
        if (programmerId != null && rawDate != null) {
          final workDate = parseDayKey(rawDate);
          final truncated = remarks.trim().length > 80
              ? '${remarks.trim().substring(0, 80)}…'
              : remarks.trim();
          try {
            await _push(
              userIds: [programmerId],
              title: 'Day sheet disapproved',
              body:
                  'Your day sheet for ${AppTime.formatDate(workDate)} needs changes: $truncated',
              data: {
                'type': 'day_sheet_disapproved',
                'navigate_to': '/programmer-tasks/day-sheets/$sheetId',
              },
            );
          } catch (e) {
            debugPrint('DaySheetsController.disapprove push error: $e');
          }
        }
      }
    } catch (e) {
      if (e is DaySheetActionException) rethrow;
      throw DaySheetActionException(mapDaySheetError(e));
    }
  }

  // -------------------------------------------------------------------------
  // Justify
  // -------------------------------------------------------------------------

  Future<void> justify({
    required String sheetId,
    required String body,
  }) async {
    if (body.trim().isEmpty) {
      throw DaySheetActionException(DaySheetError.bodyRequired);
    }
    try {
      final result = await _client.rpc(
        'justify_day_sheet',
        params: {
          'p_sheet': sheetId,
          'p_body': body.trim(),
        },
      );

      if (result is Map<String, dynamic>) {
        final notifyUserIds =
            List<String>.from(result['notify_user_ids'] as List? ?? []);
        final programmerName = result['programmer_name'] as String?;
        final rawDate = result['work_date'] as String?;
        if (notifyUserIds.isNotEmpty &&
            programmerName != null &&
            rawDate != null) {
          final workDate = parseDayKey(rawDate);
          try {
            await _push(
              userIds: notifyUserIds,
              title: 'Day sheet resubmitted',
              body:
                  '$programmerName justified their day sheet for ${AppTime.formatDate(workDate)}',
              data: {
                'type': 'day_sheet_resubmitted',
                'navigate_to': '/programmer-tasks/day-sheets/$sheetId',
              },
            );
          } catch (e) {
            debugPrint('DaySheetsController.justify push error: $e');
          }
        }
      }
    } catch (e) {
      if (e is DaySheetActionException) rethrow;
      throw DaySheetActionException(mapDaySheetError(e));
    }
  }

  // -------------------------------------------------------------------------
  // Approve (bulk)
  // -------------------------------------------------------------------------

  Future<BulkApproveResult> approve(
    List<({String sheetId, DaySheetSnapshot snapshot})> items,
  ) async {
    try {
      final params = items
          .map((e) => {
                'sheet_id': e.sheetId,
                'snapshot': e.snapshot.toMap(),
              })
          .toList();

      final result = await _client.rpc(
        'approve_day_sheets',
        params: {'p_items': params},
      ) as Map<String, dynamic>;

      final approved = List<Map<String, dynamic>>.from(
        (result['approved'] as List? ?? []).cast<Map<String, dynamic>>(),
      );
      final skippedIds =
          List<String>.from(result['skipped_ids'] as List? ?? []);

      for (final item in approved) {
        final approvedSheetId = item['sheet_id'] as String;
        final programmerId = item['programmer_id'] as String?;
        final rawDate = item['work_date'] as String?;
        if (programmerId != null && rawDate != null) {
          final workDate = parseDayKey(rawDate);
          try {
            await _push(
              userIds: [programmerId],
              title: 'Day sheet approved',
              body:
                  'Your day sheet for ${AppTime.formatDate(workDate)} was approved',
              data: {
                'type': 'day_sheet_approved',
                'navigate_to':
                    '/programmer-tasks/day-sheets/$approvedSheetId',
              },
            );
          } catch (e) {
            debugPrint('DaySheetsController.approve push error: $e');
          }
        }
      }

      return BulkApproveResult(
        approvedIds: approved.map((e) => e['sheet_id'] as String).toList(),
        skippedIds: skippedIds,
      );
    } catch (e) {
      if (e is DaySheetActionException) rethrow;
      throw DaySheetActionException(mapDaySheetError(e));
    }
  }
}

// ---------------------------------------------------------------------------
// Riverpod providers
// ---------------------------------------------------------------------------

final daySheetsControllerProvider = Provider<DaySheetsController>((ref) {
  final client = ref.watch(supabaseClientProvider);
  final notifications = ref.read(notificationsControllerProvider);
  return DaySheetsController(
    client,
    push: notifications.sendPush,
  );
});

// ---------------------------------------------------------------------------
// Stream providers
// ---------------------------------------------------------------------------

/// Day sheets for the currently authenticated programmer, newest first.
final myDaySheetsProvider =
    StreamProvider<List<ProgrammerDaySheet>>((ref) {
  final userId = ref.watch(currentUserIdProvider);
  if (userId == null) return const Stream.empty();
  final client = ref.watch(supabaseClientProvider);
  return client
      .from('programmer_day_sheets')
      .stream(primaryKey: ['id'])
      .eq('programmer_id', userId)
      .order('work_date', ascending: false)
      .map((rows) => rows.map(ProgrammerDaySheet.fromMap).toList());
});

/// Day sheets for a specific user (admin view), newest first.
final daySheetsForUserProvider =
    StreamProvider.family<List<ProgrammerDaySheet>, String>((ref, userId) {
  final client = ref.watch(supabaseClientProvider);
  return client
      .from('programmer_day_sheets')
      .stream(primaryKey: ['id'])
      .eq('programmer_id', userId)
      .order('work_date', ascending: false)
      .map((rows) => rows.map(ProgrammerDaySheet.fromMap).toList());
});

/// All day sheets visible to the current user (RLS-scoped), newest first.
final allDaySheetsProvider =
    StreamProvider<List<ProgrammerDaySheet>>((ref) {
  final client = ref.watch(supabaseClientProvider);
  return client
      .from('programmer_day_sheets')
      .stream(primaryKey: ['id'])
      .order('work_date', ascending: false)
      .map((rows) => rows.map(ProgrammerDaySheet.fromMap).toList());
});

/// A single day sheet by its ID, or null if not found.
final daySheetByIdProvider =
    StreamProvider.family<ProgrammerDaySheet?, String>((ref, id) {
  final client = ref.watch(supabaseClientProvider);
  return client
      .from('programmer_day_sheets')
      .stream(primaryKey: ['id'])
      .eq('id', id)
      .map((rows) => rows.isEmpty ? null : ProgrammerDaySheet.fromMap(rows.first));
});

/// Events for a day sheet, ordered by creation time ascending.
final daySheetEventsProvider =
    StreamProvider.family<List<ProgrammerDaySheetEvent>, String>((ref, sheetId) {
  final client = ref.watch(supabaseClientProvider);
  return client
      .from('programmer_day_sheet_events')
      .stream(primaryKey: ['id'])
      .eq('sheet_id', sheetId)
      .order('created_at', ascending: true)
      .map((rows) => rows.map(ProgrammerDaySheetEvent.fromMap).toList());
});