import 'package:didvan/main.dart';
import 'package:didvan/models/didvan_plus_model.dart';
import 'package:didvan/models/didvan_voice_model.dart';
import 'package:didvan/models/top_banner_model.dart';
import 'package:didvan/models/enums.dart';
import 'package:didvan/models/home_page_content/content.dart';
import 'package:didvan/models/home_page_content/home_page_content.dart';
import 'package:didvan/models/home_page_content/swot.dart';
import 'package:didvan/models/requests/infography.dart';
import 'package:didvan/models/requests/news.dart';
import 'package:didvan/models/requests/radar.dart';
import 'package:didvan/models/story_model.dart';
import 'package:didvan/providers/core.dart';
import 'package:didvan/routes/routes.dart';
import 'package:didvan/services/app_initalizer.dart';
import 'package:didvan/services/network/request.dart';
import 'package:didvan/services/network/request_helper.dart';
import 'package:didvan/services/story_service.dart';
import 'package:didvan/services/swot_service.dart';
import 'package:flutter/material.dart';
import 'package:url_launcher/url_launcher_string.dart';

class MainPageState extends CoreProvier {
  MainPageContent? content;
  int unread = 0;
  List<UserStories> stories = [];
  List<SwotItem> swotItems = [];
  DidvanPlusModel? didvanPlus;
  DidvanVoiceModel? didvanVoice;
  TopBannerModel? topBanner;

  Future<void> _getMainPageContent() async {
    final service = RequestService(RequestHelper.mainPageContent);
    await service.httpGet();
    if (service.isSuccess) {
      content = MainPageContent.fromJson(service.result);
      unread = service.result['unread'];
      notifyListeners();
    } else {
      notifyListeners();
      throw Exception('Failed to load main page content');
    }
  }

  int getStoryStartIndex(List<MainPageContentType> stories) {
    final firstUnreadIndex = stories.indexWhere((story) => !story.isViewed);
    return firstUnreadIndex != -1 ? firstUnreadIndex : 0;
  }

  Future<void> _getSwotItems() async {
    try {
      swotItems = await SwotService.fetchSwotItems();
    } catch (e) {
      print(e);
    }
  }

  Future<void> _getDidvanPlus() async {
    debugPrint('🎬 Fetching Didvan Plus data...');
    debugPrint('🎬 URL: ${RequestHelper.didvanPlus}');
    debugPrint('🎬 Token exists: ${RequestService.token != null}');
    
    try {
      final service = RequestService(RequestHelper.didvanPlus);
      await service.httpGet();
      
      debugPrint('🎬 Didvan Plus statusCode: ${service.statusCode}');
      
      // Check status code directly since response came
      if (service.statusCode == 200) {
        // Get the raw data using data() method
        final rawData = service.data('result');
        debugPrint('🎬 Raw data type: ${rawData.runtimeType}');
        
        if (rawData is List && rawData.isNotEmpty) {
          debugPrint('🎬 Data is List with ${rawData.length} items, taking first');
          didvanPlus = DidvanPlusModel.fromJson(Map<String, dynamic>.from(rawData[0]));
          debugPrint('✅ Didvan Plus loaded: ${didvanPlus?.id}');
          debugPrint('✅ Video file: ${didvanPlus?.file}');
          debugPrint('✅ Image: ${didvanPlus?.image}');
          notifyListeners();
        } else if (rawData is Map) {
          debugPrint('🎬 Data is Map, using directly');
          didvanPlus = DidvanPlusModel.fromJson(Map<String, dynamic>.from(rawData));
          debugPrint('✅ Didvan Plus loaded: ${didvanPlus?.id}');
          notifyListeners();
        } else {
          debugPrint('⚠️ Didvan Plus: Empty or unexpected data format');
        }
      } else {
        debugPrint('⚠️ Didvan Plus: Request failed with status ${service.statusCode}');
      }
    } catch (e) {
      debugPrint('❌ Failed to load Didvan Plus: $e');
    }
  }

  Future<void> _getDidvanVoice() async {
    debugPrint('🎙️ Fetching Didvan Voice data...');
    try {
      final service = RequestService(RequestHelper.didvanVoice);
      await service.httpGet();
      debugPrint('🎙️ Didvan Voice response: ${service.isSuccess}');
      debugPrint('🎙️ Didvan Voice result: ${service.result}');

      if (service.isSuccess) {
        final data = service.result['result'] ?? service.result;
        didvanVoice = DidvanVoiceModel.fromJson(data);
        debugPrint('✅ Didvan Voice loaded: ${didvanVoice?.id}');
        debugPrint('✅ Audio file: ${didvanVoice?.file}');
        notifyListeners();
      } else {
        debugPrint('⚠️ Didvan Voice: No result in response');
      }
    } catch (e) {
      debugPrint('❌ Failed to load Didvan Voice: $e');
    }
  }

  Future<void> _getTopBanner() async {
    try {
      final service = RequestService(RequestHelper.topBanner);
      await service.httpGet();
      if (service.statusCode == 200) {
        final data = service.result['result'] ?? service.result;
        topBanner = TopBannerModel.fromJson(data);
        debugPrint('✅ Top Banner loaded: ${topBanner?.id}');
        notifyListeners();
      } else {
        debugPrint('⚠️ Top Banner: No result in response');
      }
    } catch (e) {
      debugPrint('❌ Failed to load Top Banner: $e');
    }
  }

  Future<void> _fetchStories() async {
    try {
      stories = await StoryService.getStories();
      // print("Fetched ${stories.length} stories.");
    } catch (e) {
      stories = [];
      debugPrint("Could not fetch stories: $e");
    }
  }

  void init() {
    debugPrint("🏠 MainPageState init called");
    Future.delayed(Duration.zero, () async {
      appState = AppState.busy;
      try {
        await Future.wait([
          _getMainPageContent(),
          _fetchStories(),
          _getSwotItems(),
          _getDidvanPlus(),
          _getDidvanVoice(),
          _getTopBanner(),
        ]);
        debugPrint("✅ All main page data loaded");
        appState = AppState.idle;
      } catch (e) {
        debugPrint("❌ Main page init failed: $e");
        appState = AppState.failed;
      }
    });
    _getMainPageContent();
  }

  void markChangeHandler(String type, int id, bool value) {
    content?.lists
        .firstWhere((element) => element.type == type)
        .contents
        .firstWhere((element) => element.id == id)
        .marked = value;
    notifyListeners();
  }

  void navigationHandler(
    String type,
    int id,
    String? link, {
    String? description,
  }) {
    link = link ?? '';
    dynamic args;
    switch (type) {
      case 'infography':
        {
          link = Routes.infography;
          args = {
            'onMarkChanged': (id, value) => markChangeHandler(type, id, value),
            'id': id,
            'args': const InfographyRequestArgs(page: 0),
            'hasUnmarkConfirmation': false,
          };
          break;
        }
      case 'news':
        {
          link = Routes.newsDetails;
          args = {
            'onMarkChanged': (id, value) => markChangeHandler(type, id, value),
            'id': id,
            'args': const NewsRequestArgs(page: 0),
            'hasUnmarkConfirmation': false,
            'description': description,
          };
          break;
        }
      case 'radar':
        {
          link = Routes.radarDetails;
          args = {
            'onMarkChanged': (id, value) => markChangeHandler(type, id, value),
            'id': id,
            'args': const RadarRequestArgs(page: 0),
            'hasUnmarkConfirmation': false,
            'description': description,
          };
          break;
        }
      case 'video':
        {
          link = Routes.studioDetails;
          args = {
            'type': 'podcast',
            'id': id,
          };
          break;
        }
      case 'monthly':
        {
          Navigator.of(navigatorKey.currentContext!).pushNamed(
            Routes.pdfViewer,
            arguments: {
              'pdfUrl': link,
              'title': description ?? 'ماهنامه تحلیلی دیدوان',
            },
          );
          return;
        }
    }
    if (link == '') {
      return;
    }
    if (link.startsWith('http')) {
      AppInitializer.openWebLink(
        navigatorKey.currentContext!,
        '$link?accessToken=${RequestService.token}',
        mode: LaunchMode.inAppWebView,
      );
      return;
    }
    Navigator.of(navigatorKey.currentContext!).pushNamed(link, arguments: args);
  }
}