accountant-expert

from decimal import Decimal
from datetime import datetime
from enum import Enum
from typing import List
 
class AccountType(Enum):
    ASSET = "asset"
    LIABILITY = "liability"
    EQUITY = "equity"
    REVENUE = "revenue"
    EXPENSE = "expense"
 
class Account:
    def __init__(self, code: str, name: str, account_type: AccountType):
        self.code = code
        self.name = name
        self.type = account_type
        self.balance = Decimal('0')
        self.debit_total = Decimal('0')
        self.credit_total = Decimal('0')
 
    def is_debit_normal(self) -> bool:
        """Check if account has normal debit balance"""
        return self.type in [AccountType.ASSET, AccountType.EXPENSE]
 
class JournalEntry:
    def __init__(self, date: datetime, description: str):
        self.id = self.generate_entry_id()
        self.date = date
        self.description = description
        self.lines = []
        self.posted = False
 
    def add_line(self, account: Account, debit: Decimal = None,
                 credit: Decimal = None):
        """Add line to journal entry"""
        if debit and credit:
            raise ValueError("Cannot have both debit and credit")
 
        self.lines.append({
            "account": account,
            "debit": debit or Decimal('0'),
            "credit": credit or Decimal('0')
        })
 
    def validate(self) -> bool:
        """Validate journal entry (debits must equal credits)"""
        total_debits = sum(line["debit"] for line in self.lines)
        total_credits = sum(line["credit"] for line in self.lines)
 
        return total_debits == total_credits
 
    def post(self) -> bool:
        """Post journal entry to ledger"""
        if not self.validate():
            raise ValueError("Entry does not balance")
 
        for line in self.lines:
            account = line["account"]
            if line["debit"]:
                account.debit_total += line["debit"]
            if line["credit"]:
                account.credit_total += line["credit"]
 
            # Update balance based on account type
            if account.is_debit_normal():
                account.balance = account.debit_total - account.credit_total
            else:
                account.balance = account.credit_total - account.debit_total
 
        self.posted = True
        return True

class FinancialStatements:
    def __init__(self, company_name: str, period_end: datetime):
        self.company_name = company_name
        self.period_end = period_end
        self.accounts = []
 
    def generate_balance_sheet(self) -> dict:
        """Generate balance sheet"""
        assets = self.sum_accounts_by_type(AccountType.ASSET)
        liabilities = self.sum_accounts_by_type(AccountType.LIABILITY)
        equity = self.sum_accounts_by_type(AccountType.EQUITY)
 
        # Calculate retained earnings
        revenue = self.sum_accounts_by_type(AccountType.REVENUE)
        expenses = self.sum_accounts_by_type(AccountType.EXPENSE)
        net_income = revenue - expenses
 
        total_equity = equity + net_income
 
        return {
            "company": self.company_name,
            "period_end": self.period_end,
            "assets": {
                "current_assets": self.get_current_assets(),
                "non_current_assets": self.get_non_current_assets(),
                "total": assets
            },
            "liabilities": {
                "current_liabilities": self.get_current_liabilities(),
                "non_current_liabilities": self.get_non_current_liabilities(),
                "total": liabilities
            },
            "equity": {
                "share_capital": equity,
                "retained_earnings": net_income,
                "total": total_equity
            },
            "balanced": assets == (liabilities + total_equity)
        }
 
    def generate_income_statement(self, period_start: datetime,
                                   period_end: datetime) -> dict:
        """Generate income statement (P&L)"""
        revenue = self.sum_accounts_by_type(AccountType.REVENUE)
        expenses = self.sum_accounts_by_type(AccountType.EXPENSE)
 
        gross_profit = revenue - self.get_cogs()
        operating_expenses = self.get_operating_expenses()
        operating_income = gross_profit - operating_expenses
 
        interest_expense = self.get_interest_expense()
        tax_expense = self.calculate_tax(operating_income - interest_expense)
 
        net_income = operating_income - interest_expense - tax_expense
 
        return {
            "company": self.company_name,
            "period": f"{period_start.date()} to {period_end.date()}",
            "revenue": revenue,
            "cogs": self.get_cogs(),
            "gross_profit": gross_profit,
            "operating_expenses": operating_expenses,
            "operating_income": operating_income,
            "interest_expense": interest_expense,
            "tax_expense": tax_expense,
            "net_income": net_income,
            "eps": self.calculate_eps(net_income)
        }
 
    def generate_cash_flow_statement(self) -> dict:
        """Generate cash flow statement"""
        return {
            "operating_activities": self.calculate_operating_cash_flow(),
            "investing_activities": self.calculate_investing_cash_flow(),
            "financing_activities": self.calculate_financing_cash_flow(),
            "net_change_in_cash": self.calculate_net_cash_change(),
            "beginning_cash": self.get_beginning_cash(),
            "ending_cash": self.get_ending_cash()
        }

class TaxCalculator:
    def calculate_corporate_tax(self, taxable_income: Decimal,
                                jurisdiction: str = "US") -> dict:
        """Calculate corporate income tax"""
        if jurisdiction == "US":
            tax_rate = Decimal('0.21')  # Federal rate
        elif jurisdiction == "UK":
            tax_rate = Decimal('0.19')
        else:
            tax_rate = Decimal('0.25')  # Default rate
 
        tax_amount = taxable_income * tax_rate
 
        return {
            "taxable_income": taxable_income,
            "tax_rate": tax_rate,
            "tax_amount": tax_amount.quantize(Decimal('0.01')),
            "effective_rate": tax_rate,
            "jurisdiction": jurisdiction
        }
 
    def calculate_vat(self, net_amount: Decimal, vat_rate: Decimal) -> dict:
        """Calculate VAT/Sales tax"""
        vat_amount = net_amount * vat_rate
        gross_amount = net_amount + vat_amount
 
        return {
            "net_amount": net_amount,
            "vat_rate": vat_rate,
            "vat_amount": vat_amount.quantize(Decimal('0.01')),
            "gross_amount": gross_amount.quantize(Decimal('0.01'))
        }
 
    def calculate_depreciation(self, cost: Decimal, salvage_value: Decimal,
                              useful_life_years: int,
                              method: str = "straight_line") -> List[dict]:
        """Calculate depreciation schedule"""
        if method == "straight_line":
            annual_depreciation = (cost - salvage_value) / useful_life_years
 
            schedule = []
            book_value = cost
 
            for year in range(1, useful_life_years + 1):
                depreciation = annual_depreciation
                book_value -= depreciation
 
                schedule.append({
                    "year": year,
                    "depreciation": depreciation.quantize(Decimal('0.01')),
                    "accumulated_depreciation": (annual_depreciation * year).quantize(Decimal('0.01')),
                    "book_value": book_value.quantize(Decimal('0.01'))
                })
 
            return schedule

class FinancialRatios:
    @staticmethod
    def current_ratio(current_assets: Decimal, current_liabilities: Decimal) -> Decimal:
        """Liquidity ratio: Current Assets / Current Liabilities"""
        return (current_assets / current_liabilities).quantize(Decimal('0.01'))
 
    @staticmethod
    def quick_ratio(current_assets: Decimal, inventory: Decimal,
                    current_liabilities: Decimal) -> Decimal:
        """Acid test: (Current Assets - Inventory) / Current Liabilities"""
        return ((current_assets - inventory) / current_liabilities).quantize(Decimal('0.01'))
 
    @staticmethod
    def debt_to_equity(total_debt: Decimal, total_equity: Decimal) -> Decimal:
        """Leverage ratio: Total Debt / Total Equity"""
        return (total_debt / total_equity).quantize(Decimal('0.01'))
 
    @staticmethod
    def return_on_equity(net_income: Decimal, shareholders_equity: Decimal) -> Decimal:
        """ROE: Net Income / Shareholders' Equity"""
        return (net_income / shareholders_equity * 100).quantize(Decimal('0.01'))
 
    @staticmethod
    def return_on_assets(net_income: Decimal, total_assets: Decimal) -> Decimal:
        """ROA: Net Income / Total Assets"""
        return (net_income / total_assets * 100).quantize(Decimal('0.01'))
 
    @staticmethod
    def profit_margin(net_income: Decimal, revenue: Decimal) -> Decimal:
        """Net Profit Margin: Net Income / Revenue"""
        return (net_income / revenue * 100).quantize(Decimal('0.01'))