import 'dart:convert';

import 'package:capstone_project/models/event_signal.dart';
import 'package:capstone_project/models/watched_stock.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';

class WatchlistProvider extends ChangeNotifier {
  static const String _storageKey = 'watched_stocks';

  List<WatchedStock> _stocks = [];
  List<WatchedStock> get stocks => List.unmodifiable(_stocks);

  static WatchlistProvider of(BuildContext context) {
    return Provider.of<WatchlistProvider>(context, listen: false);
  }

  Future<void> load() async {
    final prefs = await SharedPreferences.getInstance();
    final stockStrings = prefs.getStringList(_storageKey) ?? [];

    _stocks = stockStrings.map((stockString) {
      return WatchedStock.fromJson(jsonDecode(stockString));
    }).toList();

    notifyListeners();
  }

  Future<void> save() async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.setStringList(
      _storageKey,
      _stocks.map((stock) => jsonEncode(stock.toJson())).toList(),
    );
  }

  Future<void> addStock(String ticker, String companyName) async {
    final normalizedTicker = ticker.trim().toUpperCase();
    final normalizedCompanyName = companyName.trim();

    if (normalizedTicker.isEmpty || normalizedCompanyName.isEmpty) {
      return;
    }

    final existingIndex = _stocks.indexWhere((stock) => stock.ticker == normalizedTicker);
    if (existingIndex != -1) {
      _stocks[existingIndex] = WatchedStock(
        ticker: normalizedTicker,
        companyName: normalizedCompanyName,
        latestSignal: _stocks[existingIndex].latestSignal,
        signalHistory: _stocks[existingIndex].signalHistory,
      );
    } else {
      _stocks.add(
        WatchedStock(
          ticker: normalizedTicker,
          companyName: normalizedCompanyName,
        ),
      );
    }

    await save();
    notifyListeners();
  }

  Future<void> removeStock(String ticker) async {
    _stocks.removeWhere((stock) => stock.ticker == ticker.trim().toUpperCase());
    await save();
    notifyListeners();
  }

  Future<void> updateSignals(String ticker, List<EventSignal> signals) async {
    final normalizedTicker = ticker.trim().toUpperCase();
    final stockIndex = _stocks.indexWhere((stock) => stock.ticker == normalizedTicker);

    if (stockIndex == -1) {
      return;
    }

    _stocks[stockIndex] = WatchedStock(
      ticker: _stocks[stockIndex].ticker,
      companyName: _stocks[stockIndex].companyName,
      latestSignal: signals.isNotEmpty ? signals.first : null,
      signalHistory: List<EventSignal>.from(signals),
    );

    await save();
    notifyListeners();
  }
}