using System;

using System.Collections.Generic;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Text;

using System.Text.RegularExpressions;

​

class AmazonOrder

{

    public DateTime OrderDate { get; set; }

    public string OrderNumber { get; set; }

    public string ItemDescription { get; set; }

    public int Quantity { get; set; }

    public decimal Price { get; set; }

    public string ShipTo { get; set; }

    public bool IsMedical { get; set; }

​

    public override string ToString()

    {

        return $"{OrderDate:yyyy-MM-dd},{OrderNumber},{ItemDescription},{Quantity},{Price:F2},{ShipTo},{(IsMedical ? "Y" : "N")}";

    }

}

​

class Program

{

    static void Main()

    {

        try

        {

            Console.WriteLine("Amazon Order Parser - Starting...");

            Console.WriteLine("Looking for order files in: " + Directory.GetCurrentDirectory());

            // Get all CSV, TXT, and MD files in the current directory

            string[] inputFiles = Directory.GetFiles(".", "*.*")

                .Where(file => 

                    file.EndsWith(".csv", StringComparison.OrdinalIgnoreCase) || 

                    file.EndsWith(".txt", StringComparison.OrdinalIgnoreCase) || 

                    file.EndsWith(".md", StringComparison.OrdinalIgnoreCase))

                .ToArray();

​

            Console.WriteLine($"Found {inputFiles.Length} potential files to process.");

​

            List<AmazonOrder> allOrders = new List<AmazonOrder>();

​

            // Process each file

            foreach (string file in inputFiles)

            {

                try

                {

                    string[] lines = File.ReadAllLines(file);

                    // Check if this is likely an order file (contains expected header)

                    if (lines.Length > 0 && IsOrderFileHeader(lines[0]))

                    {

                        var orders = ParseOrderFile(lines);

                        if (orders.Count > 0)

                        {

                            allOrders.AddRange(orders);

                            Console.WriteLine($"Processed {orders.Count} orders from {Path.GetFileName(file)}");

                        }

                        else

                        {

                            Console.WriteLine($"No valid orders found in {Path.GetFileName(file)}");

                        }

                    }

                    else

                    {

                        Console.WriteLine($"Skipping {Path.GetFileName(file)} - not recognized as an order file");

                    }

                }

                catch (Exception ex)

                {

                    Console.WriteLine($"Error processing {Path.GetFileName(file)}: {ex.Message}");

                }

            }

​

            if (allOrders.Count == 0)

            {

                Console.WriteLine("No orders were found. Please check that your files contain Amazon order data.");

                Console.WriteLine("Press any key to exit...");

                Console.ReadKey();

                return;

            }

​

            // Sort all orders by date (newest first)

            var sortedOrders = allOrders

                .OrderByDescending(o => o.OrderDate)

                .ThenBy(o => o.OrderNumber)

                .ToList();

​

            // Write combined results to a CSV file

            string outputFile = "combined_amazon_orders.csv";

            WriteOrdersToFile(sortedOrders, outputFile);

​

            Console.WriteLine($"Successfully combined {sortedOrders.Count} orders into {outputFile}");

​

            // Generate summary statistics

            GenerateStatistics(sortedOrders);

            Console.WriteLine("\nProcess completed successfully!");

            Console.WriteLine("Press any key to exit...");

            Console.ReadKey();

        }

        catch (Exception ex)

        {

            Console.WriteLine($"Unexpected error: {ex.Message}");

            Console.WriteLine(ex.StackTrace);

            Console.WriteLine("Press any key to exit...");

            Console.ReadKey();

        }

    }

​

    static bool IsOrderFileHeader(string line)

    {

        // Check if the line contains expected column headers

        line = line.ToLower();

        return line.Contains("order date") && 

               (line.Contains("order #") || line.Contains("order number")) && 

               (line.Contains("item description") || line.Contains("description")) &&

               (line.Contains("ship to") || line.Contains("shipto") || line.Contains("ship"));

    }

​

    static List<AmazonOrder> ParseOrderFile(string[] lines)

    {

        var orders = new List<AmazonOrder>();

        // Skip header row

        for (int i = 1; i < lines.Length; i++)

        {

            string line = lines[i].Trim();

            if (string.IsNullOrEmpty(line)) continue;

​

            try

            {

                var order = ParseOrderLine(line);

                if (order != null)

                {

                    orders.Add(order);

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine($"Error parsing line {i}: {ex.Message}");

            }

        }

​

        return orders;

    }

​

    static AmazonOrder ParseOrderLine(string line)

    {

        // Split the CSV line, handling quotes properly

        string[] parts = SplitCSVLine(line);

        if (parts.Length < 5) return null;

​

        // Handle different date formats

        DateTime orderDate = ParseOrderDate(parts[0]);

        // Parse order number

        string orderNumber = parts[1].Trim();

        // Parse item description

        string itemDescription = parts[2].Trim();

        // Parse quantity (default to 1 if not specified or invalid)

        int quantity = 1;

        if (parts.Length > 3 && !string.IsNullOrEmpty(parts[3]))

        {

            int.TryParse(parts[3].Trim(), out quantity);

            if (quantity <= 0) quantity = 1;

        }

        // Parse price

        decimal price = 0;

        if (parts.Length > 4 && !string.IsNullOrEmpty(parts[4]))

        {

            string priceText = parts[4].Trim();

            if (priceText.StartsWith("$"))

            {

                priceText = priceText.Substring(1);

            }

            decimal.TryParse(priceText, NumberStyles.Currency, CultureInfo.InvariantCulture, out price);

        }

        // Parse ship to

        string shipTo = parts.Length > 5 ? parts[5].Trim() : "";

        // Parse medical flag

        bool isMedical = false;

        if (parts.Length > 6)

        {

            string medicalText = parts[6].Trim().ToUpper();

            isMedical = medicalText == "Y" || medicalText == "YES" || medicalText == "TRUE";

        }

        return new AmazonOrder

        {

            OrderDate = orderDate,

            OrderNumber = orderNumber,

            ItemDescription = itemDescription,

            Quantity = quantity,

            Price = price,

            ShipTo = shipTo,

            IsMedical = isMedical

        };

    }

​

    static DateTime ParseOrderDate(string dateText)

    {

        dateText = dateText.Trim();

        // Try standard date formats first

        if (DateTime.TryParse(dateText, out DateTime result))

        {

            return result;

        }

        // Try custom formats

        string[] formats = {

            "yyyy-MM-dd",

            "MM/dd/yyyy",

            "MMMM d yyyy",

            "MMMM dd yyyy"

        };

        foreach (string format in formats)

        {

            if (DateTime.TryParseExact(dateText, format, CultureInfo.InvariantCulture, 

                DateTimeStyles.None, out result))

            {

                return result;

            }

        }

        // Handle "Month dd yyyy" format manually

        Regex monthDayYearRegex = new Regex(@"(\w+)\s+(\d+)\s+(\d{4})");

        Match match = monthDayYearRegex.Match(dateText);

        if (match.Success)

        {

            string month = match.Groups[1].Value;

            string day = match.Groups[2].Value;

            string year = match.Groups[3].Value;

            string reformattedDate = $"{month} {day}, {year}";

            if (DateTime.TryParse(reformattedDate, out result))

            {

                return result;

            }

        }

        // If all else fails, use current date and log error

        Console.WriteLine($"Could not parse date: {dateText}");

        return DateTime.Now;

    }

​

    static string[] SplitCSVLine(string line)

    {

        List<string> result = new List<string>();

        bool inQuotes = false;

        StringBuilder field = new StringBuilder();

        foreach (char c in line)

        {

            if (c == '"')

            {

                inQuotes = !inQuotes;

            }

            else if (c == ',' && !inQuotes)

            {

                result.Add(field.ToString());

                field.Clear();

            }

            else

            {

                field.Append(c);

            }

        }

        // Add the last field

        result.Add(field.ToString());

        return result.ToArray();

    }

​

    static void WriteOrdersToFile(List<AmazonOrder> orders, string filename)

    {

        using (StreamWriter writer = new StreamWriter(filename))

        {

            // Write header

            writer.WriteLine("OrderDate,OrderNumber,ItemDescription,Quantity,Price,ShipTo,Medical");

            // Write orders

            foreach (var order in orders)

            {

                writer.WriteLine(order.ToString());

            }

        }

    }

​

    static void GenerateStatistics(List<AmazonOrder> orders)

    {

        // Total spending

        decimal totalSpending = orders.Sum(o => o.Price);

        decimal medicalSpending = orders.Where(o => o.IsMedical).Sum(o => o.Price);

        decimal nonMedicalSpending = orders.Where(o => !o.IsMedical).Sum(o => o.Price);

        // Count by month

        var ordersByMonth = orders

            .GroupBy(o => new { o.OrderDate.Year, o.OrderDate.Month })

            .Select(g => new {

                YearMonth = $"{g.Key.Year}-{g.Key.Month:D2}",

                Count = g.Count(),

                Total = g.Sum(o => o.Price)

            })

            .OrderByDescending(x => x.YearMonth)

            .ToList();

        // Count by recipient

        var ordersByRecipient = orders

            .GroupBy(o => o.ShipTo)

            .Select(g => new {

                Recipient = g.Key,

                Count = g.Count(),

                Total = g.Sum(o => o.Price)

            })

            .OrderByDescending(x => x.Count)

            .ToList();

        // Write statistics to file

        using (StreamWriter writer = new StreamWriter("amazon_order_statistics.txt"))

        {

            writer.WriteLine("Amazon Order Statistics");

            writer.WriteLine("=======================");

            writer.WriteLine();

            writer.WriteLine($"Total Orders: {orders.Count}");

            writer.WriteLine($"Total Spending: ${totalSpending:F2}");

            writer.WriteLine($"Medical Spending: ${medicalSpending:F2} ({medicalSpending / totalSpending:P1})");

            writer.WriteLine($"Non-Medical Spending: ${nonMedicalSpending:F2} ({nonMedicalSpending / totalSpending:P1})");

            writer.WriteLine();

            writer.WriteLine("Orders by Month");

            writer.WriteLine("--------------");

            foreach (var month in ordersByMonth)

            {

                writer.WriteLine($"{month.YearMonth}: {month.Count} orders, ${month.Total:F2}");

            }

            writer.WriteLine();

            writer.WriteLine("Orders by Recipient");

            writer.WriteLine("-------------------");

            foreach (var recipient in ordersByRecipient)

            {

                writer.WriteLine($"{recipient.Recipient}: {recipient.Count} orders, ${recipient.Total:F2}");

            }

            writer.WriteLine();

            // Most common items (top 10)

            var commonItems = orders

                .GroupBy(o => o.ItemDescription)

                .Select(g => new {

                    Item = g.Key,

                    Count = g.Count(),

                    Total = g.Sum(o => o.Price)

                })

                .OrderByDescending(x => x.Count)

                .Take(10)

                .ToList();

            writer.WriteLine("Most Commonly Ordered Items");

            writer.WriteLine("--------------------------");

            foreach (var item in commonItems)

            {

                writer.WriteLine($"{item.Item}: {item.Count} orders, ${item.Total:F2}");

            }

​

            // Most expensive items (top 10)

            var expensiveItems = orders

                .GroupBy(o => o.ItemDescription)

                .Select(g => new {

                    Item = g.Key,

                    Count = g.Count(),

                    Total = g.Sum(o => o.Price),

                    AveragePrice = g.Average(o => o.Price)

                })

                .OrderByDescending(x => x.AveragePrice)

                .Take(10)

                .ToList();

            writer.WriteLine();

            writer.WriteLine("Most Expensive Items");

            writer.WriteLine("--------------------");

            foreach (var item in expensiveItems)

            {

                writer.WriteLine($"{item.Item}: ${item.AveragePrice:F2} avg, {item.Count} orders");

            }

​

            // Monthly spending trend

            writer.WriteLine();

            writer.WriteLine("Monthly Spending Trend");

            writer.WriteLine("---------------------");

            foreach (var month in ordersByMonth)

            {

                decimal medicalTotal = orders

                    .Where(o => o.IsMedical && 

                           o.OrderDate.Year == int.Parse(month.YearMonth.Split('-')[0]) && 

                           o.OrderDate.Month == int.Parse(month.YearMonth.Split('-')[1]))

                    .Sum(o => o.Price);

                decimal nonMedicalTotal = month.Total - medicalTotal;

                writer.WriteLine($"{month.YearMonth}: ${month.Total:F2} total (Medical: ${medicalTotal:F2}, Non-Medical: ${nonMedicalTotal:F2})");

            }

        }

        Console.WriteLine("Statistics written to amazon_order_statistics.txt");

    }

}