SuccessForm.cs

using System;
using System.Collections.Generic;
using System.Drawing.Text;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using TL;
using TLSharp.Core.Network.Exceptions;
using WTelegram;

namespace Telegram_File_downloader
{
    public partial class Telepop : Form
    {
        private Client client;
        private List<string> _allChannels; // Store all channels for easy searching
        private string _downloadFolderPath;
        private int _downloadedFilesCounter = 0; // Counter for downloaded files
        private CancellationTokenSource _cancellationTokenSource; // Source for the cancellation token
        private const string SelectionFilePath = "selected_channels.txt"; // Path to the file where selections are saved

        public Telepop(Client client)
        {
            InitializeComponent();
            this.client = client;


            lblprogressshow.Text = "";

            // Redirect console output
            Console.SetOut(new TextBoxWriter(txtConsoleOutput));

            // Load channels initially when the form is created
            LoadChannelsAsync();

            // Example console output
            Console.WriteLine("Console output redirected to TextBox.");

        }

        // Event handler for the Sort button
        private void btnSortChannels_Click(object sender, EventArgs e)
        {
            if (_allChannels != null)
            {
                // Sort channels alphabetically
                var sortedChannels = _allChannels.OrderBy(channel => channel).ToList();

                // Clear and repopulate the CheckedListBox with sorted channels
                channelCheckedListBox.Items.Clear();
                channelCheckedListBox.Items.AddRange(sortedChannels.ToArray());
            }
            else
            {
                MessageBox.Show("No channels available to sort.");
            }
        }

        private void Telepop_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Log out by disposing of the client
            if (client != null)
            {
                client.Dispose();
                client = null;
                Console.WriteLine("Logged out successfully.");
            }
        }

        private void BtnLogout_Click(object sender, EventArgs e)
        {
            // Dispose of the client to log out
            client?.Dispose();
            client = null;

            // Show the LoginForm
            LoginForm loginForm = new LoginForm();
            loginForm.Show();

            // Close the current form
            this.Close();
        }

        private void BtnSaveSelection_Click(object sender, EventArgs e)
        {
            SaveSelectedChannels();
        }

        private void BtnLoadSelection_Click(object sender, EventArgs e)
        {
            LoadSelectedChannels();
        }

        private void SaveSelectedChannels()
        {
            try
            {
                var selectedChannels = channelCheckedListBox.CheckedItems.Cast<string>().ToList();
                File.WriteAllLines(SelectionFilePath, selectedChannels);
                MessageBox.Show("Channel selection saved successfully.");
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error saving channel selection: {ex.Message}");
            }
        }

        private void LoadSelectedChannels()
        {
            try
            {
                if (File.Exists(SelectionFilePath))
                {
                    var savedChannels = File.ReadAllLines(SelectionFilePath).ToList();
                    for (int i = 0; i < channelCheckedListBox.Items.Count; i++)
                    {
                        var channel = channelCheckedListBox.Items[i].ToString();
                        channelCheckedListBox.SetItemChecked(i, savedChannels.Contains(channel));
                    }
                }
                else
                {
                    MessageBox.Show("No saved selection found.");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error loading channel selection: {ex.Message}");
            }
        }

        private async Task<List<string>> FetchChannelsAsync()
        {
            var dialogs = await client.Messages_GetAllDialogs(); // Retrieve all dialogs
            var channels = new List<string>();

            foreach (var chat in dialogs.chats.Values)
            {
                if (chat is Channel channel)
                {
                    channels.Add(channel.title); // Add channel titles to the list
                }
            }
            return channels;
        }

        private async void LoadChannelsAsync()
        {
            try
            {
                channelCheckedListBox.Items.Clear(); // Clear the existing items
                _allChannels = await FetchChannelsAsync(); // Fetch all channels
                channelCheckedListBox.Items.AddRange(_allChannels.ToArray()); // Add new items
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error loading channels: " + ex.Message);
            }
        }

        private void BtnUpdate_Click(object sender, EventArgs e)
        {
            LoadChannelsAsync(); // Reload channels when update button is clicked
        }

        private void btnSearchChannels_Click(object sender, EventArgs e)
        {
            SearchChannels(txtSearchChannels.Text);
            SaveSelectedChannels();
        }

        private void TxtSearchChannels_TextChanged(object sender, EventArgs e)
        {
            SearchChannels(txtSearchChannels.Text);
            SaveSelectedChannels();
        }
        private void SearchChannels(string searchText)
        {
            if (string.IsNullOrWhiteSpace(searchText))
            {
                // If search text is empty, display all channels
                channelCheckedListBox.Items.Clear();
                channelCheckedListBox.Items.AddRange(_allChannels.ToArray());
            }
            else
            {
                // Filter channels based on search text
                var filteredChannels = _allChannels
                    .Where(channel => channel.IndexOf(searchText, StringComparison.OrdinalIgnoreCase) >= 0)
                    .ToArray();

                // Update CheckedListBox with filtered channels
                channelCheckedListBox.Items.Clear();
                channelCheckedListBox.Items.AddRange(filteredChannels);
            }
        }

        private void BtnChooseFolder_Click(object sender, EventArgs e)
        {
            using (var folderBrowserDialog = new FolderBrowserDialog())
            {
                // Show the folder browser dialog
                DialogResult result = folderBrowserDialog.ShowDialog();

                if (result == DialogResult.OK && !string.IsNullOrWhiteSpace(folderBrowserDialog.SelectedPath))
                {
                    _downloadFolderPath = folderBrowserDialog.SelectedPath; // Store the chosen folder path
                    lblDownloadFolder.Text = $"{_downloadFolderPath}"; // Update label with path
                }
            }
        }

        private async void BtnDownload_Click(object sender, EventArgs e)
        {
            try
            {
                // Disable buttons while downloading
                SetControlsEnabled(false);

                if (!ValidateInputs()) return;

                _cancellationTokenSource = new CancellationTokenSource();

                DateTime fromDate = dtpFromDate.Value.Date.ToUniversalTime();
                DateTime toDate = dtpToDate.Value.Date.AddDays(1).AddTicks(-1).ToUniversalTime(); // End of the day in UTC

                var selectedFileTypes = GetSelectedFileTypes();
                var selectedChannels = channelCheckedListBox.CheckedItems.Cast<string>().ToList();

                foreach (var channelTitle in selectedChannels)
                {
                    await DownloadFilesFromChannel(channelTitle, fromDate, toDate, selectedFileTypes, _cancellationTokenSource.Token);
                }

                MessageBox.Show("Download complete!");
            }
            catch (OperationCanceledException)
            {
                // Catch the OperationCanceledException and suppress further exceptions
                if (_cancellationTokenSource.IsCancellationRequested)
                {
                    Console.WriteLine("Download canceled!");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred during download: {ex.Message}");
            }
            finally
            {
                // Re-enable buttons when done
                SetControlsEnabled(true);
            }
        }

        private void SetControlsEnabled(bool enabled)
        {
            btnDownload.Enabled = enabled;
            btnLogout.Enabled = enabled;
            btnSaveSelection.Enabled = enabled;
            btnLoadSelection.Enabled = enabled;
            btnChooseFolder.Enabled = enabled;
            BtnUpdate.Enabled = enabled;
            txtSearchChannels.Enabled = enabled;
            dtpFromDate.Enabled = enabled;
            dtpToDate.Enabled = enabled;
            numMinSize.Enabled = enabled;
            numMaxSize.Enabled = enabled;
            chkTxt.Enabled = enabled;
            chkRar.Enabled = enabled;
            chkZip.Enabled = enabled;
            chk7z.Enabled = enabled;
            channelCheckedListBox.Enabled = enabled;
            btnSortChannels.Enabled = enabled;
        }

        private bool ValidateInputs()
        {
            // Validate date selection
            if (dtpFromDate.Value >= dtpToDate.Value)
            {
                MessageBox.Show("The 'From' date must be earlier than the 'To' date.");
                return false;
            }

            // Validate download folder
            if (string.IsNullOrEmpty(_downloadFolderPath))
            {
                MessageBox.Show("Please select a download folder.");
                return false;
            }

            // Validate channel selection
            if (channelCheckedListBox.CheckedItems.Count == 0)
            {
                MessageBox.Show("Please select at least one channel.");
                return false;
            }

            return true;
        }

        private List<string> GetSelectedFileTypes()
        {
            var fileTypes = new List<string>();

            if (chkTxt.Checked) fileTypes.Add(".txt");
            if (chkTxt.Checked) fileTypes.Add(".rtf");
            if (chkRar.Checked) fileTypes.Add(".rar");
            if (chkZip.Checked) fileTypes.Add(".zip");
            if (chk7z.Checked) fileTypes.Add(".7z");


            // If no file type is selected, consider downloading all types
            if (!fileTypes.Any())
            {
                fileTypes.Add(".txt");
                fileTypes.Add(".rtf");
                fileTypes.Add(".rar");
                fileTypes.Add(".zip");
                fileTypes.Add(".7z");
            }

            return fileTypes;
        }

        private async Task DownloadFilesFromChannel(string channelTitle, DateTime fromDate, DateTime toDate, List<string> selectedFileTypes, CancellationToken cancellationToken)
        {
            try
            {
                var dialogs = await client.Messages_GetAllDialogs();
                var channel = dialogs.chats.Values.OfType<Channel>().FirstOrDefault(c => c.title == channelTitle);

                if (channel == null)
                {
                    MessageBox.Show($"Channel {channelTitle} not found.");
                    return;
                }

                // Initialize date filter
                var offsetDate = toDate;

                // Fetch messages in the specified date range
                var allMessages = new List<TL.Message>();
                const int limit = 100;  // Adjust the limit as needed
                bool hasMoreMessages = true;

                while (hasMoreMessages)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    try
                    {
                        var messageHistory = await client.Messages_GetHistory(channel, limit: limit, offset_date: offsetDate);
                        var messagesInRange = messageHistory.Messages
                                                             .OfType<TL.Message>()
                                                             .Where(msg => msg.date >= fromDate && msg.date <= toDate)
                                                             .ToList();

                        allMessages.AddRange(messagesInRange);

                        var lastMessage = messageHistory.Messages.OfType<TL.Message>().LastOrDefault();
                        if (lastMessage == null || lastMessage.date < fromDate)
                        {
                            hasMoreMessages = false;
                        }
                        else
                        {
                            offsetDate = lastMessage.date;
                        }

                        if (!messagesInRange.Any())
                        {
                            break;
                        }
                    }
                    catch (FloodException ex) when (ex.Message.Contains("FLOOD_WAIT"))
                    {
                        int waitTime = int.Parse(ex.Message.Split('_').Last());
                        MessageBox.Show($"Flood wait error. Retrying after {waitTime} seconds...");
                        await Task.Delay(waitTime * 1000, cancellationToken);
                    }
                }


                foreach (var msg in allMessages)
                {
                    // Check for cancellation before processing each message
                    cancellationToken.ThrowIfCancellationRequested();

                    if (msg.media is TL.MessageMediaDocument mediaDoc)
                    {
                        var doc = mediaDoc.document as TL.Document;
                        if (doc != null && doc.mime_type != null)
                        {
                            cancellationToken.ThrowIfCancellationRequested();

                            var fileSizeMB = doc.size / (1024.0 * 1024); // Convert bytes to MB

                            // Convert NumericUpDown values to double for comparison
                            double minSizeMB = (double)numMinSize.Value;
                            double maxSizeMB = (double)numMaxSize.Value;

                            if (fileSizeMB < minSizeMB || fileSizeMB > maxSizeMB)
                            {
                                continue; // Skip files that do not meet the size criteria
                            }

                            // Check file extension against selected file types
                            string extension = Path.GetExtension(doc.Filename).ToLower();

                            // Only download if the extension is in the selected file types
                            if (selectedFileTypes.Contains(extension))
                            {
                                await DownloadFile(doc, channelTitle, cancellationToken);
                            }
                        }
                    }
                }
            }
            catch (OperationCanceledException)
            {
                lblprogressshow.Text = "";
                Console.WriteLine("Download Cancelled!.....");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred during download: {ex.Message}");
            }
        }

        private async Task DownloadFile(Document document, string channelTitle, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            try
            {
                // Get the original filename from the document
                string originalFilename = document.Filename;

                // Define invalid characters typically not allowed in filenames
                char[] invalidChars = Path.GetInvalidFileNameChars();

                // Sanitize filename using the SanitizeName method
                string sanitizedFilename = SanitizeName(originalFilename, invalidChars, "default_filename");
                string extension = Path.GetExtension(originalFilename);

                // Ensure the extension is appended only once to avoid duplication
                if (!sanitizedFilename.EndsWith(extension, StringComparison.OrdinalIgnoreCase))
                {
                    sanitizedFilename += extension;
                }

                // Determine the file path in the download folder
                string filePath = Path.Combine(_downloadFolderPath, sanitizedFilename);

                // Check if the file already exists and has the same size
                if (File.Exists(filePath))
                {
                    long existingFileSize = new FileInfo(filePath).Length;
                    if (existingFileSize == document.size)
                    {
                        return; // File already exists and sizes match, skip downloading
                    }

                    // If sizes differ, create a new file with an incremented index
                    int fileIndex = 1;
                    string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(sanitizedFilename);
                    while (File.Exists(filePath))
                    {
                        filePath = Path.Combine(_downloadFolderPath, $"{fileNameWithoutExtension} ({fileIndex++}){extension}");
                    }
                }

                // Download the file
                using (var cts = new CancellationTokenSource())
                {
                    await DownloadDocumentLineByLineAsync(document, filePath, cts.Token);
                }

                // Update the downloaded files counter and UI label
                _downloadedFilesCounter++;
                lblDownloadedCounter.Text = $"Downloaded Files: {_downloadedFilesCounter}";
            }
            catch (OperationCanceledException)
            {
                // Handle cancellation gracefully
                if (cancellationToken.IsCancellationRequested)
                {
                    lblprogressshow.Text = "";
                }
            }
            catch (Exception ex)
            {
                // Handle other exceptions and log errors
                Console.WriteLine($"An error occurred in file download: {ex.Message}");
            }
        }
        private async Task DownloadDocumentLineByLineAsync(Document document, string filePath, CancellationToken cancellationToken)
        {
            // Reset progress to zero

            long totalBytes = document.size; // The total size of the document
            long bytesReceived = 0; // To track the number of bytes received so far
            int mbtotalBytes = (int)(totalBytes / 1024 / 1024);
            lblfilesize.Text = $"Recent File Size: {mbtotalBytes} MB";

            using (var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.None))
            using (var streamWriter = new StreamWriter(fileStream))
            {
                using (var memoryStream = new MemoryStream())
                {
                    await client.DownloadFileAsync(document, memoryStream);
                    memoryStream.Seek(0, SeekOrigin.Begin);

                    using (var streamReader = new StreamReader(memoryStream))
                    {
                        // Check for cancellation at the start of each loop iteration
                        cancellationToken.ThrowIfCancellationRequested();
                        string line;
                        while ((line = await streamReader.ReadLineAsync()) != null)
                        {
                            // Calculate bytes received
                            bytesReceived += Encoding.UTF8.GetByteCount(line + Environment.NewLine);

                            // Report progress
                            double percentComplete = (double)bytesReceived / totalBytes * 100;
                            percentComplete = Math.Min(percentComplete, 100.0); // Clamp to 100%
                            Console.WriteLine($"{percentComplete:F2}%"); // For debugging purposes
                            // Write each line to the file
                            await streamWriter.WriteLineAsync(line);
                        }
                    }
                }
            }
        }
        // Method to sanitize filenames by removing invalid characters
        private string SanitizeName(string name, char[] invalidChars, string defaultName)
        {
            // Replace invalid characters with underscores
            foreach (char invalidChar in invalidChars)
            {
                name = name.Replace(invalidChar, '_');
            }

            // Additional sanitization for known problematic characters
            string[] additionalInvalidChars = { "@", "#", " ", ":", "/", "\\", "*", "?", "\"", "<", ">", "|", "⚡️", "👍", "🐍", "💸", "🦅", "⛅️", "🌩️", "🌓" };
            foreach (string invalidChar in additionalInvalidChars)
            {
                name = name.Replace(invalidChar, "_");
            }

            // Limit name length to prevent path length issues
            if (name.Length > 100)
            {
                name = name.Substring(0, 100);
            }

            // If name is empty after sanitization, assign a default name
            if (string.IsNullOrWhiteSpace(name))
            {
                name = defaultName;
            }

            return name;
        }

        private void txt_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                // Call the button click event or the download logic directly
                BtnDownload_Click(sender, e);

                // Suppress the default beep sound on Enter key press
                e.SuppressKeyPress = true;
            }
        }

        private string SanitizeFilename(string filename)
        {
            return SanitizeName(filename, Path.GetInvalidFileNameChars(), "unnamed_file");
        }

        private string SanitizeFolderName(string folderName)
        {
            return SanitizeName(folderName, Path.GetInvalidPathChars(), "unnamed_folder");
        }

        // Add this method for the Stop button click event
        private void btnCancel_Click(object sender, EventArgs e)
        {
            if (_cancellationTokenSource != null && !_cancellationTokenSource.IsCancellationRequested)
            {
                var result = MessageBox.Show("Are you sure you want to cancel the download?", "Confirm Cancel", MessageBoxButtons.YesNo);
                if (result == DialogResult.Yes)
                {
                    lblprogressshow.Text = "Please wait for the recent file to be downloaded.....";
                    _cancellationTokenSource.Cancel();
                    _downloadedFilesCounter = 0;
                }
            }
        }
    }
}