hym_ui/lib/api_service.dart

import 'package:flutter/material.dart';
import 'package:http/http.dart' as http;
import 'dart:convert';
import 'dart:ui_web' as ui;
import 'dart:html' as html;

class MailAddress {
  final String? name;
  final String address;
  MailAddress({this.name, required this.address});

  factory MailAddress.fromJson(Map<String, dynamic> json) {
    return MailAddress(
      name: json['name'],
      address: json['address'],
    );
  }
}

class SerializableMessage {
  final String name;
  final String from;
  final List<MailAddress> to;
  final List<MailAddress> cc;
  final String hash;

  // final String path;
  final String subject;
  final String date;
  final int uid;
  final String list;
  final String id;
  final String in_reply_to;

  SerializableMessage({
    required this.name,
    required this.from,
    required this.to,
    required this.cc,
    required this.hash,
    required this.subject,
    required this.date,
    required this.uid,
    required this.list,
    required this.id,
    required this.in_reply_to,
  });

  factory SerializableMessage.fromJson(Map<String, dynamic> json) {
    var toList = json['to'] as List;
    var ccList = json['cc'] as List;

    return SerializableMessage(
      name: json['name'],
      from: json['from'],
      // to: json['name', 'address']
      to: toList.map((i) => MailAddress.fromJson(i)).toList(),
      cc: ccList.map((i) => MailAddress.fromJson(i)).toList(),
      // path: json['path'],
      hash: json['hash'],
      subject: json['subject'],
      date: json['date'],
      uid: json['uid'],
      list: json['list'],
      id: json['id'],
      in_reply_to: json['in_reply_to'],
    );
  }
}

class EmailPage extends StatefulWidget {
  const EmailPage({super.key});
  final String title = 'Emails';

  @override
  State<EmailPage> createState() => _EmailPageState();
}

class _EmailPageState extends State<EmailPage> {
  List emails = [];

  void _displayEmailsFromFolder(String folder) async {
    // Map<String, List<SerializableMessage>> messagesMap = {};
    List<SerializableMessage> allEmails = [];

    try {
      var url = Uri.http(
          '127.0.0.1:3001', 'sorted_threads_by_date', {'folder': folder});
      var response = await http.get(url);
      // print(response.body);
      // Map<String, dynamic> json = jsonDecode(response.body); original

      // json.forEach((key, value) {
      //   List<SerializableMessage> messages = (value as List)
      //       .map((item) => SerializableMessage.fromJson(item))
      //       .toList();
      //   messagesMap[key] = messages;
      // });

      // new shit
      if (response.statusCode == 200) {
        List<dynamic> json = jsonDecode(response.body);
        for (var item in json) {
          if (item.length > 1 && item[0] is String && item[1] is List) {
            //  print('Date: ${item[0]}, Threads: ${item[1]}');
            List<int> threadIDs = List<int>.from(item[1]);
            for (var threadId in threadIDs) {
              await fetchThreadMessages(threadId, allEmails);
            }
          }
        }
      } else {
        throw Exception('Failed to load threads');
      }
    } catch (e) {
      print('_displayEmailsFromFolder caught error: $e');
    }
    setState(() {
      emails.clear();
      // emails = messagesMap.values.toList().expand((list) => list).toList();
      emails.addAll(allEmails);
      // print(emails);
      ;
    });
  }

  Future<void> fetchThreadMessages(
      int threadId, List<SerializableMessage> allEmails) async {
    try {
      var url = Uri.http(
          '127.0.0.1:3001', 'get_thread_messages', {'id': threadId.toString()});
      // print(url);
      var response = await http.get(url);
      // print(response.body);
      if (response.statusCode == 200) {
        List<dynamic> messagesJson = jsonDecode(response.body);
        List<SerializableMessage> messages =
            messagesJson.map((mj) => SerializableMessage.fromJson(mj)).toList();
        allEmails.addAll(messages);
      } else {
        throw Exception(
            'Failed to fetch thread messages for thread ID: $threadId');
      }
    } catch (e) {
      print('Error fetching thread messages: $e');
    }
  }

  Future<String> _getEmailContent(String id) async {
    String content = r"""

    """;
    // String restcontent = "";
    try {
      var url = Uri.http('127.0.0.1:3001', 'email', {'id': id});
      // print(url);
      var response = await http.get(url);
      // print(response.body);
      if (response.statusCode == 200) {
        print('ok');
        content = response.body;
        // try {
        //   var restUrl =
        //       Uri.http('127.0.0.1:3001', 'get_thread_messages', {'id': id});
        //   // print(restUrl);
        //   var restresponse = await http.get(restUrl);
        //   // print(restresponse.statusCode);
        //   if (restresponse.statusCode == 200) {
        //     print("ok squared");
        //     // restcontent = restresponse.body;
        //   }
        // } catch (i) {
        //   print('jsoncontent caught error: $i');
        // }
      }
    } catch (e) {
      print('_getEmailContent caught error: $e');
    }
    // print(content);
    // print(restcontent);
    return content;
  }

  Future<String> _getThreadMessagesJson(String threadId) async {
    String jsonResponse = "";

    try {
      var url =
          Uri.http('127.0.0.1:3001', 'get_thread_messages', {'id': threadId});
      // print(url);
      var response = await http.get(url);
      // print(response.statusCode);
      // print(response.body);
      if (response.statusCode == 200) {
        jsonResponse = response.body; // Here you get the JSON response
      } else {
        throw Exception('Failed to load thread messages');
      }
    } catch (e) {
      print('_getThreadMessagesJson caught error: $e');
    }

    return jsonResponse; // Returns the JSON string
  }

  Future<List<Widget>> _getDrawerItems() async {
    List<String> drawerItems = [];

    try {
      var url = Uri.http('127.0.0.1:3001', 'folders');
      var response = await http.get(url);
      drawerItems = List<String>.from(json.decode(response.body));
    } catch (e) {
      print('_getDrawerItems caught error: $e');
    }

    List<Widget> drawerWidgets = [];

    for (String item in drawerItems) {
      drawerWidgets.add(
        ListTile(
          leading: Icon(Icons.mail),
          title: Text(item),
          onTap: () {
            _displayEmailsFromFolder(item);
            Navigator.pop(context);
          },
        ),
      );
    }

    return drawerWidgets;
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
        title: Text(widget.title),
      ),
      drawer: Drawer(
        child: FutureBuilder<List<Widget>>(
          future:
              _getDrawerItems(), // call the async function to get the future
          builder:
              (BuildContext context, AsyncSnapshot<List<Widget>> snapshot) {
            if (snapshot.connectionState == ConnectionState.waiting) {
              // While data is loading, show a progress indicator
              return Center(child: CircularProgressIndicator());
            } else if (snapshot.hasError) {
              // If something went wrong, show an error message
              return Center(child: Text('Error: ${snapshot.error}'));
            } else {
              // When data is fetched successfully, display the items
              return ListView(
                padding: EdgeInsets.zero,
                children:
                    snapshot.data!, // Unwrap the data once confirmed it's there
              );
            }
          },
        ),
      ),
      body: EmailListScreen(
          emails: emails,
          getEmailContent: _getEmailContent,
          getJsonEmail: _getThreadMessagesJson),
    );
  }
}

class EmailListScreen extends StatelessWidget {
  final List emails;
  final Future<String> Function(String) getEmailContent;
  final Future<String> Function(String) getJsonEmail;

  EmailListScreen(
      {required this.emails,
      required this.getEmailContent,
      required this.getJsonEmail});

  @override
  Widget build(BuildContext context) {
    // print(emails);
    return Scaffold(
      appBar: AppBar(
        title: Text('Emails'),
      ),
      body: ListView.separated(
        itemCount: emails.length,
        itemBuilder: (context, index) {
          return ListTile(
              title: Text(emails[index].from,
                  style: TextStyle(fontWeight: FontWeight.bold)),
              subtitle: Column(
                crossAxisAlignment: CrossAxisAlignment.start,
                children: [
                  Text(emails[index].subject),
                ],
              ),
              trailing: Text(emails[index].date.toString()),
              onTap: () async {
                String emailContent = await getEmailContent(emails[index].id);
                String jsonContent =
                    await getJsonEmail(emails[index].uid.toString());
                // print(emails[index]);
                String from = emails[index].from;
                String name = emails[index].name;
                String to = emails[index].to;
                String cc = emails[index].cc;
                String hash = emails[index].hash;
                String subject = emails[index].subject;
                String date = emails[index].date;
                String uid = emails[index].uid;
                String list = emails[index].list;
                String id = emails[index].id;
                String in_reply_to = emails[index].in_reply_to;
                // String jsonbuilt = 
                Navigator.push(
                  context,
                  MaterialPageRoute(
                      builder: (context) => EmailView(
                            emailContent: emailContent,
                            jsonEmail: jsonContent,
                          )),
                );
              });
        },
        separatorBuilder: (context, index) {
          return Divider();
        },
      ),
    );
  }
}

class EmailView extends StatefulWidget {
  final String emailContent;
  final String jsonEmail;



  const EmailView(
      {Key? key, required this.emailContent, required this.jsonEmail})
      : super(key: key);
  @override
  _EmailViewState createState() => _EmailViewState();
}

class _EmailViewState extends State<EmailView> {
  @override
  void initState() {
    super.initState();
    ui.platformViewRegistry.registerViewFactory(
      'html-view33',
      (int viewId) => html.IFrameElement()
        ..width = '100%'
        ..height = '100%'
        ..srcdoc = widget.emailContent
        ..style.border = 'none',
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.name),
      ),
      body: Container(
        child: HtmlElementView(
          viewType: 'html-view33',
        ),
      ),
    );
  }
}