#include <sstream>
#include <stdexcept>
#include "Invoice.h"
#include "Factory.h"
#include "InventoryItem.h"
#include "StringHelper.h"

int Invoice::m_uid = 0;

Invoice::Invoice()
    : m_id("INV" + std::to_string(++m_uid)),
    m_booking(nullptr),
    m_laborCost(0.0),
    m_partsCost(0.0),
    m_discountPercentage(0.0),
    m_totalAmount(0.0),
    m_paymentMethod(util::PaymentMode()),
    m_status(util::PaymentStatus()) {}

Invoice::Invoice(
    const std::string& bookingId,
    ServiceBooking* booking,
    const util::Timestamp& invoiceDate, 
    double laborCost, const util::Map<std::string,
    InventoryItem*>& parts,
    double partsCost,
    double discountPercentage, 
    double totalAmount, 
    const util::Timestamp& paymentDate, 
    util::PaymentMode paymentMethod, 
    util::PaymentStatus status
    )
    : m_id("INV" + std::to_string(++m_uid)),
    m_bookingId(bookingId),
    m_booking(booking),
    m_invoiceDate(invoiceDate),
    m_laborCost(laborCost),
    m_parts(parts),
    m_partsCost(partsCost),
    m_discountPercentage(discountPercentage),
    m_totalAmount(totalAmount),
    m_paymentDate(paymentDate),
    m_paymentMethod(paymentMethod),
    m_status(status) 
{
    int numberOfParts = m_parts.getSize();
    auto partPointers = m_parts.getValues();
    for (int index = 0; index < numberOfParts; index++)
    {
        m_partIDs.push_back(partPointers[index]->getId());
    }
}

Invoice::Invoice(
    const std::string& id,
    const std::string& bookingId,
    const util::Timestamp& invoiceDate,
    const util::Vector<std::string>& partIDs,
    double laborCost,
    double partsCost,
    double discountPercentage,
    double totalAmount,
    const util::Timestamp& paymentDate,
    util::PaymentMode paymentMethod,
    util::PaymentStatus status
)
    : m_id(id),
    m_bookingId(bookingId),
    m_booking(nullptr),
    m_invoiceDate(invoiceDate),
    m_partIDs(partIDs),
    m_laborCost(laborCost),
    m_partsCost(partsCost),
    m_discountPercentage(discountPercentage),
    m_totalAmount(totalAmount),
    m_paymentDate(paymentDate),
    m_paymentMethod(paymentMethod),
    m_status(status)
{
    int idNumber = util::extractNumber(m_id);
    if (idNumber > m_uid)
    {
        m_uid = idNumber;
    }
}

const std::string& Invoice::getId() const
{
    return m_id;
}

const std::string& Invoice::getBookingId() const
{
    return m_bookingId;
}

ServiceBooking* Invoice::getBooking() const
{
    return m_booking;
}

const util::Timestamp& Invoice::getInvoiceDate() const
{
    return m_invoiceDate;
}

double Invoice::getLaborCost() const
{
    return m_laborCost;
}

/*
Function: getPartIDs
Description: Retrieves the IDs of parts used in the invoice.
Parameters:
    - None
Returns:
    - const util::Vector<std::string>&: Part IDs
*/
const util::Vector<std::string>& Invoice::getPartIDs() const
{
    return m_partIDs;
}

const util::Map<std::string, InventoryItem*>& Invoice::getParts() const
{
    return m_parts;
}

double Invoice::getPartsCost() const
{
    return m_partsCost;
}

double Invoice::getDiscountPercentage() const
{
    return m_discountPercentage;
}

double Invoice::getTotalAmount() const
{
    return m_totalAmount;
}

const util::Timestamp& Invoice::getPaymentDate() const
{
    return m_paymentDate;
}

util::PaymentMode Invoice::getPaymentMethod() const
{
    return m_paymentMethod;
}

util::PaymentStatus Invoice::getStatus() const
{
    return m_status;
}

void Invoice::setId(const std::string& id)
{
    m_id = id;
}

void Invoice::setBookingId(const std::string& bookingId)
{
    m_bookingId = bookingId;
}

void Invoice::setBooking(ServiceBooking* booking)
{
    m_booking = booking;
}

void Invoice::setInvoiceDate(const util::Timestamp& invoiceDate)
{
    m_invoiceDate = invoiceDate;
}

void Invoice::setLaborCost(double laborCost)
{
    m_laborCost = laborCost;
}

void Invoice::setParts(const util::Map<std::string, InventoryItem*>& parts)
{
    m_parts = parts;
    m_partIDs.clear();
    int numberOfParts = m_parts.getSize();
    auto partPointers = m_parts.getValues();
    for (int index = 0; index < numberOfParts; index++)
    {
        m_partIDs.push_back(partPointers[index]->getId());
    }
}

void Invoice::setPartsCost(double partsCost)
{
    m_partsCost = partsCost;
}

void Invoice::setDiscountPercentage(double discountPercentage)
{
    m_discountPercentage = discountPercentage;
}

void Invoice::setTotalAmount(double totalAmount)
{
    m_totalAmount = totalAmount;
}

void Invoice::setPaymentDate(const util::Timestamp& paymentDate)
{
    m_paymentDate = paymentDate;
}

void Invoice::setPaymentMethod(util::PaymentMode paymentMethod)
{
    m_paymentMethod = paymentMethod;
}

void Invoice::setStatus(util::PaymentStatus status)
{
    m_status = status;
}

/*
Function: getPartIDsAsString (static helper)
Description: Converts a vector of part IDs into a single string separated by '|'.
Parameters:
    - partIDs: const util::Vector<std::string>&, vector of part IDs
Returns:
    - std::string: Concatenated part IDs string
*/
static std::string getPartIDsAsString(const util::Vector<std::string>& partIDs)
{
    int numberOfParts = partIDs.getSize();
    std::string partIDsString;
    for (int index = 0; index < numberOfParts; index++)
    {
        partIDsString += partIDs[index];
        if (index < numberOfParts - 1)
        {
            partIDsString += '|';
        }
    }
    return partIDsString;
}

/*
Function: getPartIDsAsVector (static helper)
Description: Converts a string of part IDs separated by '|' into a vector.
Parameters:
    - partIDsString: const std::string&, concatenated part IDs string
Returns:
    - util::Vector<std::string>: Vector of part IDs
*/
static util::Vector<std::string> getPartIDsAsVector(const std::string& partIDsString)
{
    util::Vector<std::string> partIDs;
    std::string partID;
    std::istringstream serializedPartIDs(partIDsString);
    while (getline(serializedPartIDs, partID, '|'))
    {
        partIDs.push_back(partID);
    }
    return partIDs;
}

/*
Function: serialize
Description: Serializes the invoice into a CSV-formatted string.
Parameters:
    - None
Returns:
    - std::string: Serialized invoice record
*/
std::string Invoice::serialize() const
{
    std::ostringstream serializedInvoice;
    serializedInvoice << m_id << ','
        << m_bookingId << ','
        << m_invoiceDate.toString() << ','
        << m_laborCost << ','
        << getPartIDsAsString(m_partIDs) << ','
        << m_partsCost << ','
        << m_discountPercentage << ','
        << m_totalAmount << ','
        << m_paymentDate.toString() << ','
        << util::getPaymentModeString(m_paymentMethod) << ','
        << util::getPaymentStatusString(m_status);
    return serializedInvoice.str();
}

/*
Function: deserialize
Description: Deserializes a CSV-formatted string into an Invoice object.
Parameters:
    - record: const std::string&, serialized invoice record
Returns:
    - Invoice*: Pointer to the deserialized Invoice object
Throws:
    - std::runtime_error if data is invalid
*/
Invoice* Invoice::deserialize(const std::string& record)
{
    std::string id, bookingId;
    std::string invoiceDateString, laborCostString, partIDsString;
    std::string partsCostString, discountPercentageString, totalAmountString;
    std::string paymentDateString, paymentMethodString, statusString;
    double laborCost, partsCost, discountPercentage, totalAmount;
    std::istringstream serializedInvoice(record);
    getline(serializedInvoice, id, ',');
    getline(serializedInvoice, bookingId, ',');
    getline(serializedInvoice, invoiceDateString, ',');
    getline(serializedInvoice, laborCostString, ',');
    getline(serializedInvoice, partIDsString, ',');
    getline(serializedInvoice, partsCostString, ',');
    getline(serializedInvoice, discountPercentageString, ',');
    getline(serializedInvoice, totalAmountString, ',');
    getline(serializedInvoice, paymentDateString, ',');
    getline(serializedInvoice, paymentMethodString, ',');
    getline(serializedInvoice, statusString, ',');
    util::Timestamp invoiceDate;
    util::Timestamp paymentDate;
    try
    {
        invoiceDate = util::Timestamp::fromString(invoiceDateString);
        paymentDate = util::Timestamp::fromString(paymentDateString);
        laborCost = std::stod(laborCostString);
        partsCost = std::stod(partsCostString);
        discountPercentage = std::stod(discountPercentageString);
        totalAmount = std::stod(totalAmountString);
    }
    catch (...)
    {
        throw std::runtime_error("Invalid invoice data");
    }
    util::Vector<std::string> partIDs = getPartIDsAsVector(partIDsString);
    util::PaymentMode paymentMethod = util::getPaymentMode(paymentMethodString);
    util::PaymentStatus status = util::getPaymentStatus(statusString);
    return Factory::getObject<Invoice>(
        id,
        bookingId,
        invoiceDate,
        partIDs,
        laborCost,
        partsCost,
        discountPercentage,
        totalAmount,
        paymentDate,
        paymentMethod,
        status
    );
}

/*
Function: getHeaders
Description: Retrieves the CSV headers for invoice serialization.
Parameters:
    - None
Returns:
    - std::string: Header string ("ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status")
*/
std::string Invoice::getHeaders()
{
    return "ID,BookingID,InvoiceDate,LaborCost,PartIDs,PartsCost,DiscountPercentage,TotalAmount,PaymentDate,PaymentMethod,Status";
}