Revert "Merge branch 'main' of https://huggingface.co/spaces/Zenaight/planify"

This reverts commit c0fc75bb4bdd67a034bf624d7991da5a639775f3, reversing
changes made to d4b6186c2f8321449b6bf3c3cb8ba723212e68df.

app/CurrencyMapping/__init__.py

@@ -0,0 +1,17 @@
+# Currency Mapping Package
+
+import os
+import sys
+
+# Add the current directory to sys.path to handle the space in folder name
+current_dir = os.path.dirname(__file__)
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# Import the main function for easy access
+from currency_mapping import convert_currency_symbols_to_iso, canonical_currency_map
+
+__all__ = [
+    'convert_currency_symbols_to_iso',
+    'canonical_currency_map'
+]

app/CurrencyMapping/currency_mapping.py

@@ -0,0 +1,538 @@
+# Currency Mapping Module
+# Contains canonical_currency_map dictionary and convert_currency_symbols_to_iso() function
+
+# Canonical currency map for symbol resolution (matches TypeScript version)
+canonical_currency_map = {
+    # Standard currency symbols
+    "$": "USD",
+    "£": "GBP", 
+    "€": "EUR",
+    "¥": "JPY",
+    "₹": "INR",
+    "₽": "RUB",
+    "₩": "KRW",
+    "₪": "ILS",
+    "₺": "TRY",
+    "₴": "UAH",
+    "₼": "AZN",
+    "₸": "KZT",
+    "₾": "GEL",
+    "֏": "AMD",
+    "₲": "PYG",
+    "₡": "CRC",
+    "₣": "XPF",
+    "₦": "NGN",
+    "₵": "GHS",
+    "₨": "PKR",
+    "₱": "PHP",
+    "₫": "VND",
+    "₭": "LAK",
+    "៛": "KHR",
+    "৳": "BDT",
+    "؋": "AFN",
+    "﷼": "IRR",
+    
+    # Custom symbols
+    "‡": "CUSTOM_DAGGER",
+    "†": "CUSTOM_DAGGER_SINGLE",
+    
+    # Letter-based currencies
+    "R": "ZAR",  # South African Rand
+    "C$": "CAD",  # Canadian Dollar
+    "A$": "AUD",  # Australian Dollar
+    "R$": "BRL",  # Brazilian Real
+    "S/": "PEN",  # Peruvian Sol
+    "Bs": "BOB",  # Bolivian Boliviano
+    "Q": "GTQ",  # Guatemalan Quetzal
+    "L": "HNL",  # Honduran Lempira
+    "ƒ": "AWG",  # Aruban Florin
+    "Vt": "VUV",  # Vanuatu Vatu
+    "T$": "TOP",  # Tongan Pa'anga
+    "T": "WST",  # Samoan Tala
+    "лв": "BGN",  # Bulgarian Lev
+    "Kč": "CZK",  # Czech Koruna
+    "kr": "DKK",  # Danish Krone
+    "Ft": "HUF",  # Hungarian Forint
+    "zł": "PLN",  # Polish Zloty
+    "lei": "RON",  # Romanian Leu
+    "CHF": "CHF",  # Swiss Franc
+    "KM": "BAM",  # Bosnian Marka
+    "ден": "MKD",  # North Macedonian Denar
+    "дин": "RSD",  # Serbian Dinar
+    "so'm": "UZS",  # Uzbekistani Som
+    "NT$": "TWD",  # Taiwan Dollar
+    "HK$": "HKD",  # Hong Kong Dollar
+    "S$": "SGD",  # Singapore Dollar
+    "RM": "MYR",  # Malaysian Ringgit
+    "฿": "THB",  # Thai Baht
+    "Rp": "IDR",  # Indonesian Rupiah
+    "K": "MMK",  # Myanmar Kyat
+    "Rs": "LKR",  # Sri Lankan Rupee
+    "Nu": "BTN",  # Bhutanese Ngultrum
+    "MVR": "MVR",  # Maldivian Rufiyaa
+    
+    # Middle Eastern currencies
+    "ع.د": "IQD",  # Iraqi Dinar
+    "ل.ل": "LBP",  # Lebanese Pound
+    "د.ا": "JOD",  # Jordanian Dinar
+    "ر.س": "SAR",  # Saudi Riyal
+    "د.إ": "AED",  # UAE Dirham
+    "ر.ق": "QAR",  # Qatari Riyal
+    "د.ك": "KWD",  # Kuwaiti Dinar
+    "د.ب": "BHD",  # Bahraini Dinar
+    "ر.ع.": "OMR",  # Omani Rial
+    "ر.ي": "YER",  # Yemeni Rial
+    "ج.م": "EGP",  # Egyptian Pound
+    "ل.د": "LYD",  # Libyan Dinar
+    "د.ت": "TND",  # Tunisian Dinar
+    "د.ج": "DZD",  # Algerian Dinar
+    "د.م.": "MAD",  # Moroccan Dirham
+    "ج.س.": "SDG",  # Sudanese Pound
+    "SSP": "SSP",  # South Sudanese Pound
+    
+    # African currencies
+    "KSh": "KES",  # Kenyan Shilling
+    "USh": "UGX",  # Ugandan Shilling
+    "TSh": "TZS",  # Tanzanian Shilling
+    "FRw": "RWF",  # Rwandan Franc
+    "FBu": "BIF",  # Burundian Franc
+    "MT": "MZN",  # Mozambican Metical
+    "P": "BWP",  # Botswanan Pula
+    "N$": "NAD",  # Namibian Dollar
+    "Ar": "MGA",  # Malagasy Ariary
+    "CF": "KMF",  # Comorian Franc
+    "MK": "MWK",  # Malawian Kwacha
+    "ZK": "ZMW",  # Zambian Kwacha
+    "Kz": "AOA",  # Angolan Kwanza
+    "FC": "CDF",  # Congolese Franc
+    "FCFA": "XAF",  # Central African Franc
+    "Db": "STD",  # Sao Tomean Dobra
+    "D": "GMD",  # Gambian Dalasi
+    "FG": "GNF",  # Guinean Franc
+    "CFA": "XOF",  # West African Franc
+    "Le": "SLL",  # Sierra Leonean Leone
+    "L$": "LRD",  # Liberian Dollar
+    "Br": "ETB",  # Ethiopian Birr
+    "Nfk": "ERN",  # Eritrean Nakfa
+    "Fdj": "DJF",  # Djiboutian Franc
+    "S": "SOS",  # Somali Shilling
+    
+    # Caribbean & Central American currencies
+    "J$": "JMD",  # Jamaican Dollar
+    "BZ$": "BZD",  # Belize Dollar
+    "TT$": "TTD",  # Trinidad and Tobago Dollar
+    "Bds$": "BBD",  # Barbadian Dollar
+    "EC$": "XCD",  # East Caribbean Dollar
+    "GY$": "GYD",  # Guyanese Dollar
+    "SRD": "SRD",  # Surinamese Dollar
+    "RD$": "DOP",  # Dominican Peso
+    
+    # Pacific Island currencies
+    "FJ$": "FJD",  # Fijian Dollar
+    "PGK": "PGK",  # Papua New Guinean Kina
+    "SI$": "SBD",  # Solomon Islands Dollar
+    "WS$": "WST",  # Samoan Tala
+    "VT": "VUV",  # Vanuatu Vatu
+    
+    # European currencies
+    "ISK": "ISK",  # Icelandic Krona
+    "Lt": "LTL",  # Lithuanian Litas
+    "Ls": "LVL",  # Latvian Lats
+    "EEK": "EEK",  # Estonian Kroon
+    "NOK": "NOK",  # Norwegian Krone
+    "SEK": "SEK",  # Swedish Krona
+    "ALL": "ALL",  # Albanian Lek
+    
+    # South American currencies
+    "Gs": "PYG",  # Paraguayan Guarani
+    "Bs.S": "VES",  # Venezuelan Bolívar Soberano
+    "Bs": "VEF",  # Venezuelan Bolívar
+    "$U": "UYU",  # Uruguayan Peso
+    "$a": "ARS",  # Argentine Peso
+    "$b": "BOB",  # Bolivian Boliviano
+    "CLP": "CLP",  # Chilean Peso
+    "COP": "COP",  # Colombian Peso
+    "MXN": "MXN",  # Mexican Peso
+    
+    # Small Island Nations
+    "BMD": "BMD",  # Bermudian Dollar
+    "BSD": "BSD",  # Bahamian Dollar
+    "KYD": "KYD",  # Cayman Islands Dollar
+    "TVD": "TVD",  # Tuvaluan Dollar
+    "ZWL": "ZWL",  # Zimbabwean Dollar
+    
+    # Additional African currencies
+    "LSL": "LSL",  # Lesotho Loti
+    "SZL": "SZL",  # Swazi Lilangeni
+    "CVE": "CVE",  # Cape Verdean Escudo
+    "MRO": "MRO",  # Mauritanian Ouguiya
+    "MRU": "MRU",  # Mauritanian Ouguiya
+    "SCR": "SCR",  # Seychellois Rupee
+    "SHP": "SHP",  # Saint Helena Pound
+    
+    # Additional Asian currencies
+    "BND": "BND",  # Brunei Dollar
+    "MOP": "MOP",  # Macanese Pataca
+    "NPR": "NPR",  # Nepalese Rupee
+    
+    # Additional Pacific currencies
+    "NZD": "NZD",  # New Zealand Dollar
+    
+    # Alternative $ symbols for countries (context-dependent)
+    "$BMD": "BMD",  # Bermudian Dollar
+    "$BSD": "BSD",  # Bahamian Dollar
+    "$BZD": "BZD",  # Belize Dollar
+    "$KYD": "KYD",  # Cayman Islands Dollar
+    "$FJD": "FJD",  # Fijian Dollar
+    "$GYD": "GYD",  # Guyanese Dollar
+    "$JMD": "JMD",  # Jamaican Dollar
+    "$LRD": "LRD",  # Liberian Dollar
+    "$NAD": "NAD",  # Namibian Dollar
+    "$SBD": "SBD",  # Solomon Islands Dollar
+    "$SRD": "SRD",  # Surinamese Dollar
+    "$TTD": "TTD",  # Trinidad and Tobago Dollar
+    "$TVD": "TVD",  # Tuvaluan Dollar
+    "$VUV": "VUV",  # Vanuatu Vatu
+    "$WST": "WST",  # Samoan Tala
+    "$XCD": "XCD",  # East Caribbean Dollar
+    "$ZWL": "ZWL",  # Zimbabwean Dollar
+    "$BWP": "BWP",  # Botswanan Pula
+    "$LSL": "LSL",  # Lesotho Loti
+    "$SZL": "SZL",  # Swazi Lilangeni
+    "$ZAR": "ZAR",  # South African Rand
+    "$HKD": "HKD",  # Hong Kong Dollar
+    "$SGD": "SGD",  # Singapore Dollar
+    "$TWD": "TWD",  # Taiwan Dollar
+    "$CHF": "CHF",  # Swiss Franc
+    "$DKK": "DKK",  # Danish Krone
+    "$NOK": "NOK",  # Norwegian Krone
+    "$SEK": "SEK",  # Swedish Krona
+    "$ARS": "ARS",  # Argentine Peso
+    "$BOB": "BOB",  # Bolivian Boliviano
+    "$CLP": "CLP",  # Chilean Peso
+    "$COP": "COP",  # Colombian Peso
+    "$MXN": "MXN",  # Mexican Peso
+    "$PEN": "PEN",  # Peruvian Sol
+    "$UYU": "UYU",  # Uruguayan Peso
+    "$VES": "VES",  # Venezuelan Bolívar Soberano
+    
+    # Cryptocurrencies (for modern business plans)
+    "₿": "BTC",  # Bitcoin
+    "Ξ": "ETH",  # Ethereum
+    "Ł": "LTC",  # Litecoin
+    
+    # Special Drawing Rights
+    "XDR": "XDR",  # Special Drawing Rights
+    
+    # Precious Metals
+    "XAU": "XAU",  # Gold (troy ounce)
+    "XAG": "XAG",  # Silver (troy ounce)
+    "XPT": "XPT",  # Platinum (troy ounce)
+    "XPD": "XPD",  # Palladium (troy ounce)
+    
+    # Other
+    "XTS": "XTS",  # Testing Currency Code
+    "XXX": "XXX",  # No Currency
+    
+    # Missing currencies from canonical_currency_map.py
+    "ADP": "ADP",  # Andorran Peseta
+    "AFA": "AFA",  # Afghan Afghani (1927–2002)
+    "ALK": "ALK",  # Albanian Lek (1946–1965)
+    "ANG": "ANG",  # Netherlands Antillean Guilder
+    "AOK": "AOK",  # Angolan Kwanza (1977–1991)
+    "AON": "AON",  # Angolan New Kwanza (1990–2000)
+    "AOR": "AOR",  # Angolan Readjusted Kwanza (1995–1999)
+    "ARA": "ARA",  # Argentine Austral
+    "ARL": "ARL",  # Argentine Peso Ley (1970–1983)
+    "ARM": "ARM",  # Argentine Peso (1881–1970)
+    "ARP": "ARP",  # Argentine Peso (1983–1985)
+    "ATS": "ATS",  # Austrian Schilling
+    "AZM": "AZM",  # Azerbaijani Manat (1993–2006)
+    "BAD": "BAD",  # Bosnia-Herzegovina Dinar (1992–1994)
+    "BAN": "BAN",  # Bosnia-Herzegovina New Dinar (1994–1997)
+    "BEC": "BEC",  # Belgian Franc (convertible)
+    "BEF": "BEF",  # Belgian Franc
+    "BEL": "BEL",  # Belgian Franc (financial)
+    "BGL": "BGL",  # Bulgarian Hard Lev
+    "BGM": "BGM",  # Bulgarian Socialist Lev
+    "BGO": "BGO",  # Bulgarian Lev (1879–1952)
+    "BOL": "BOL",  # Bolivian Boliviano (1863–1963)
+    "BOP": "BOP",  # Bolivian Peso
+    "BOV": "BOV",  # Bolivian Mvdol
+    "BRB": "BRB",  # Brazilian New Cruzeiro (1967–1986)
+    "BRC": "BRC",  # Brazilian Cruzado (1986–1989)
+    "BRE": "BRE",  # Brazilian Cruzeiro (1990–1993)
+    "BRN": "BRN",  # Brazilian New Cruzado (1989–1990)
+    "BRR": "BRR",  # Brazilian Cruzeiro (1993–1994)
+    "BRZ": "BRZ",  # Brazilian Cruzeiro (1942–1967)
+    "BUK": "BUK",  # Burmese Kyat
+    "BYB": "BYB",  # Belarusian Ruble (1994–1999)
+    "BYN": "BYN",  # Belarusian Ruble
+    "BYR": "BYR",  # Belarusian Ruble (2000–2016)
+    "CA$": "CAD",  # Canadian Dollar
+    "CHE": "CHE",  # WIR Euro
+    "CHW": "CHW",  # WIR Franc
+    "CLE": "CLE",  # Chilean Escudo
+    "CLF": "CLF",  # Chilean Unit of Account (UF)
+    "CNH": "CNH",  # Chinese Yuan (offshore)
+    "CNX": "CNX",  # Chinese People's Bank Dollar
+    "CN¥": "CNY",  # Chinese Yuan
+    "COU": "COU",  # Colombian Real Value Unit
+    "CSD": "CSD",  # Serbian Dinar (2002–2006)
+    "CSK": "CSK",  # Czechoslovak Hard Koruna
+    "CUC": "CUC",  # Cuban Convertible Peso
+    "CUP": "CUP",  # Cuban Peso
+    "CYP": "CYP",  # Cypriot Pound
+    "DDM": "DDM",  # East German Mark
+    "DEM": "DEM",  # German Mark
+    "ECS": "ECS",  # Ecuadorian Sucre
+    "ECV": "ECV",  # Ecuadorian Unit of Constant Value
+    "ESA": "ESA",  # Spanish Peseta (A account)
+    "ESB": "ESB",  # Spanish Peseta (convertible account)
+    "ESP": "ESP",  # Spanish Peseta
+    "FIM": "FIM",  # Finnish Markka
+    "FKP": "FKP",  # Falkland Islands Pound
+    "FRF": "FRF",  # French Franc
+    "GEK": "GEK",  # Georgian Kupon Larit
+    "GHC": "GHC",  # Ghanaian Cedi (1979–2007)
+    "GIP": "GIP",  # Gibraltar Pound
+    "GNS": "GNS",  # Guinean Syli
+    "GQE": "GQE",  # Equatorial Guinean Ekwele
+    "GRD": "GRD",  # Greek Drachma
+    "GWE": "GWE",  # Portuguese Guinea Escudo
+    "GWP": "GWP",  # Guinea-Bissau Peso
+    "HRD": "HRD",  # Croatian Dinar
+    "HRK": "HRK",  # Croatian Kuna
+    "HTG": "HTG",  # Haitian Gourde
+    "IEP": "IEP",  # Irish Pound
+    "ILP": "ILP",  # Israeli Pound
+    "ILR": "ILR",  # Israeli Shekel (1980–1985)
+    "ISJ": "ISJ",  # Icelandic Króna (1918–1981)
+    "ITL": "ITL",  # Italian Lira
+    "KGS": "KGS",  # Kyrgystani Som
+    "KPW": "KPW",  # North Korean Won
+    "KRH": "KRH",  # South Korean Hwan (1953–1962)
+    "KRO": "KRO",  # South Korean Won (1945–1953)
+    "LTT": "LTT",  # Lithuanian Talonas
+    "LUC": "LUC",  # Luxembourgian Convertible Franc
+    "LUF": "LUF",  # Luxembourgian Franc
+    "LUL": "LUL",  # Luxembourg Financial Franc
+    "LVR": "LVR",  # Latvian Ruble
+    "MAF": "MAF",  # Moroccan Franc
+    "MCF": "MCF",  # Monegasque Franc
+    "MDC": "MDC",  # Moldovan Cupon
+    "MDL": "MDL",  # Moldovan Leu
+    "MGF": "MGF",  # Malagasy Franc
+    "MKN": "MKN",  # Macedonian Denar (1992–1993)
+    "MLF": "MLF",  # Malian Franc
+    "MNT": "MNT",  # Mongolian Tugrik
+    "MTL": "MTL",  # Maltese Lira
+    "MTP": "MTP",  # Maltese Pound
+    "MUR": "MUR",  # Mauritian Rupee
+    "MVP": "MVP",  # Maldivian Rupee (1947–1981)
+    "MX$": "MXN",  # Mexican Peso
+    "MXP": "MXP",  # Mexican Silver Peso (1861–1992)
+    "MXV": "MXV",  # Mexican Investment Unit
+    "MZE": "MZE",  # Mozambican Escudo
+    "MZM": "MZM",  # Mozambican Metical (1980–2006)
+    "NIC": "NIC",  # Nicaraguan Córdoba (1988–1991)
+    "NIO": "NIO",  # Nicaraguan Córdoba
+    "NLG": "NLG",  # Dutch Guilder
+    "NZ$": "NZD",  # New Zealand Dollar
+    "PAB": "PAB",  # Panamanian Balboa
+    "PEI": "PEI",  # Peruvian Inti
+    "PES": "PES",  # Peruvian Sol (1863–1965)
+    "PLZ": "PLZ",  # Polish Zloty (1950–1995)
+    "PTE": "PTE",  # Portuguese Escudo
+    "RHD": "RHD",  # Rhodesian Dollar
+    "ROL": "ROL",  # Romanian Leu (1952–2006)
+    "RUR": "RUR",  # Russian Ruble (1991–1998)
+    "SDD": "SDD",  # Sudanese Dinar (1992–2007)
+    "SDP": "SDP",  # Sudanese Pound (1957–1998)
+    "SIT": "SIT",  # Slovenian Tolar
+    "SKK": "SKK",  # Slovak Koruna
+    "SLE": "SLE",  # Sierra Leonean Leone
+    "SRG": "SRG",  # Surinamese Guilder
+    "STN": "STN",  # São Tomé & Príncipe Dobra
+    "SUR": "SUR",  # Soviet Rouble
+    "SVC": "SVC",  # Salvadoran Colón
+    "SYP": "SYP",  # Syrian Pound
+    "TJR": "TJR",  # Tajikistani Ruble
+    "TJS": "TJS",  # Tajikistani Somoni
+    "TMM": "TMM",  # Turkmenistani Manat (1993–2009)
+    "TMT": "TMT",  # Turkmenistani Manat
+    "TPE": "TPE",  # Timorese Escudo
+    "TRL": "TRL",  # Turkish Lira (1922–2005)
+    "UAK": "UAK",  # Ukrainian Karbovanets
+    "UGS": "UGS",  # Ugandan Shilling (1966–1987)
+    "USN": "USN",  # US Dollar (Next day)
+    "USS": "USS",  # US Dollar (Same day)
+    "UYI": "UYI",  # Uruguayan Peso (Indexed Units)
+    "UYP": "UYP",  # Uruguayan Peso (1975–1993)
+    "UYW": "UYW",  # Uruguayan Nominal Wage Index Unit
+    "VEB": "VEB",  # Venezuelan Bolívar (1871–2008)
+    "VED": "VED",  # Bolívar Soberano
+    "VNN": "VNN",  # Vietnamese Dong (1978–1985)
+    "XBA": "XBA",  # European Composite Unit
+    "XBB": "XBB",  # European Monetary Unit
+    "XBC": "XBC",  # European Unit of Account (XBC)
+    "XBD": "XBD",  # European Unit of Account (XBD)
+    "Cg.": "XCG",  # Caribbean guilder
+    "XEU": "XEU",  # European Currency Unit
+    "XFO": "XFO",  # French Gold Franc
+    "XFU": "XFU",  # French UIC-Franc
+    "F CFA": "XOF",  # West African CFA Franc
+    "XRE": "XRE",  # RINET Funds
+    "XSU": "XSU",  # Sucre
+    "XUA": "XUA",  # ADB Unit of Account
+    "¤": "XXX",  # Unknown Currency
+    "YDD": "YDD",  # Yemeni Dinar
+    "YUD": "YUD",  # Yugoslavian Hard Dinar (1966–1990)
+    "YUM": "YUM",  # Yugoslavian New Dinar (1994–2002)
+    "YUN": "YUN",  # Yugoslavian Convertible Dinar (1990–1992)
+    "YUR": "YUR",  # Yugoslavian Reformed Dinar (1992–1993)
+    "ZAL": "ZAL",  # South African Rand (financial)
+    "ZMK": "ZMK",  # Zambian Kwacha (1968–2012)
+    "ZRN": "ZRN",  # Zairean New Zaire (1993–1998)
+    "ZRZ": "ZRZ",  # Zairean Zaire (1971–1993)
+    "ZWD": "ZWD",  # Zimbabwean Dollar (1980–2008)
+    "ZWG": "ZWG",  # Zimbabwean Gold
+    "ZWR": "ZWR",  # Zimbabwean Dollar (2008)
+    "US$": "USD",  # US Dollar
+    "C$": "NIO",  # Nicaraguan Córdoba
+    "TT$": "TTD",  # Trinidad & Tobago Dollar
+    "BD$": "BBD",  # Barbadian Dollar
+    "B$": "BND",  # Brunei Dollar
+    "SI$": "SBD",  # Solomon Islands Dollar
+    "G$": "GYD",  # Guyanaese Dollar
+    "SR$": "SRD",  # Surinamese Dollar
+    "CLP$": "CLP",  # Chilean Peso
+    "Bs.": "VES",  # Venezuelan Bolívar
+    "Rf": "MVR",  # Maldivian Rufiyaa
+    "SSh": "SOS",  # Somali Shilling
+    "GH₵": "GHS",  # Ghanaian Cedi
+    "Br": "BYN",  # Belarusian Ruble
+    "CFA F": "XOF",  # West African CFA Franc
+    "CFAF": "XAF",  # Central African CFA Franc
+    "JP¥": "JPY",  # Japanese Yen
+    "元": "TWD",  # New Taiwan Dollar
+    "TL": "TRY",  # Turkish Lira
+    "лв.": "BGN",  # Bulgarian Lev
+    "₮": "MNT",  # Mongolian Tugrik
+    "﷼": "SAR",  # Saudi Riyal
+    ".د.ب": "BHD",  # Bahraini Dinar
+    "ل.س": "SYP",  # Syrian Pound
+    "﷼‎": "IRR",  # Iranian Rial
+    "ש״ח": "ILS",  # Israeli New Shekel
+    "Fr": "CHF",  # Swiss Franc
+    "CFP": "XPF",  # CFP Franc
+    "E": "SZL",  # Swazi Lilangeni
+    "Rf.": "MVR",  # Maldivian Rufiyaa
+    "QR": "QAR",  # Qatari Riyal
+    "SR": "SAR",  # Saudi Riyal
+    "BD": "BHD",  # Bahraini Dinar
+    "KD": "KWD",  # Kuwaiti Dinar
+    "₯": "GRD",  # Greek Drachma
+    "ЅМ": "TJS",  # Tajikistani Somoni
+    "Br (BYN)": "BYN",  # Belarusian Ruble
+    "B/.": "PAB",  # Panamanian Balboa
+    "Gs.": "PYG",  # Paraguayan Guarani
+    "Afl.": "AWG",  # Aruban Florin
+    "NAƒ": "ANG",  # Netherlands Antillean Guilder
+    "lei (MDL)": "MDL",  # Moldovan Leu
+    "KM (BAM)": "BAM",  # Bosnia-Herzegovina Convertible Mark
+    "ден (MKD)": "MKD",  # Macedonian Denar
+    "kn": "HRK",  # Croatian Kuna
+    "Z$": "ZWL",  # Zimbabwean Dollar (2009–2024)
+    "RTGS$": "ZWL",  # Zimbabwean Dollar (2009–2024)
+    "Skr": "SEK",  # Swedish Krona
+    "Nkr": "NOK",  # Norwegian Krone
+    "Dkr": "DKK",  # Danish Krone
+    "Íkr": "ISK",  # Icelandic Króna
+    "AU$": "AUD",  # Australian Dollar
+    "SG$": "SGD",  # Singapore Dollar
+    "BB$": "BBD",  # Barbadian Dollar
+    "BS$": "BSD",  # Bahamian Dollar
+    "KY$": "KYD",  # Cayman Islands Dollar
+    "BM$": "BMD",  # Bermudan Dollar
+    "JM$": "JMD",  # Jamaican Dollar
+}
+
+def convert_currency_symbols_to_iso(text: str) -> str:
+    """
+    Convert currency symbols to ISO codes for PDF compatibility
+    Matches the TypeScript canonicalCurrencyMap logic
+    """
+    import re  # Import at function level to avoid scope issues
+    processed_text = text
+    
+    # Track all conversions for detailed logging
+    conversions_made = []
+    total_conversions = 0
+    
+    # Process each currency symbol in the canonical map
+    for symbol, iso_code in canonical_currency_map.items():
+        if symbol in processed_text:
+            # Check if it's a single character
+            is_single_character = len(symbol) == 1
+            is_unicode_currency = is_single_character and ord(symbol) > 127  # Non-ASCII
+            is_latin_single_letter = is_single_character and symbol.isalpha() and ord(symbol) < 128
+            
+            # Handle multi-character symbols (like "Le", "KSh", etc.)
+            is_multi_char_symbol = len(symbol) > 1
+            
+            # Skip plain Latin single letters (to avoid converting words like "A", "R", etc.)
+            # but DO convert single-character Unicode currency symbols like €, £, ¥, ؋, etc.
+            if not is_unicode_currency and is_latin_single_letter:
+                # Only convert if it's followed by a number (currency context)
+                # Pattern: R500, R 500, R500,000 etc.
+                pattern = rf'\b{re.escape(symbol)}\s*(\d{{1,3}}(?:,?\d{{3}})*(?:\.\d{{2}})?)\b'
+                matches = re.findall(pattern, processed_text)
+                
+                if matches:
+                    old_text = processed_text
+                    processed_text = re.sub(pattern, rf'{iso_code} \1', processed_text)
+                    
+                    if old_text != processed_text:
+                        conversions_made.append(f"{symbol} → {iso_code} (context: {matches})")
+                        total_conversions += len(matches)
+                continue
+            
+            # For multi-character symbols like "Ar", "Le", etc., be very careful
+            # Only convert if they appear as standalone words or in currency contexts
+            if is_multi_char_symbol and len(symbol) == 2 and symbol.isalpha():
+                # Only convert if it's a standalone word or followed by a number
+                # Pattern: \bAr\b or \bAr\s*\d or \bLe\b or \bLe\s*\d
+                standalone_pattern = rf'\b{re.escape(symbol)}\b'
+                currency_pattern = rf'\b{re.escape(symbol)}\s*(\d{{1,3}}(?:,?\d{{3}})*(?:\.\d{{2}})?)'
+                
+                # Check for standalone occurrences first
+                standalone_matches = re.findall(standalone_pattern, processed_text)
+                currency_matches = re.findall(currency_pattern, processed_text)
+                
+                if standalone_matches or currency_matches:
+                    old_text = processed_text
+                    # Replace standalone occurrences
+                    processed_text = re.sub(standalone_pattern, iso_code, processed_text)
+                    # Replace currency context occurrences
+                    processed_text = re.sub(currency_pattern, rf'{iso_code} \1', processed_text)
+                    
+                    if old_text != processed_text:
+                        conversions_made.append(f"{symbol} → {iso_code} (standalone/currency context)")
+                        total_conversions += len(standalone_matches) + len(currency_matches)
+                continue
+            
+            # For all other symbols (Unicode currency symbols, multi-character symbols)
+            # Count occurrences before replacement
+            old_count = processed_text.count(symbol)
+            
+            # Replace all occurrences
+            old_text = processed_text
+            processed_text = processed_text.replace(symbol, iso_code)
+            
+            # Check if replacement actually happened
+            if old_text != processed_text:
+                conversions_made.append(f"{symbol} → {iso_code} ({old_count} instances)")
+                total_conversions += old_count
+    
+    return processed_text

app/DocumentGeneration/__init__.py

@@ -0,0 +1,56 @@
+# Document Generation Package
+
+import os
+import sys
+
+# Add the current directory to sys.path to handle the space in folder name
+current_dir = os.path.dirname(__file__)
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# Import all the main functions for easy access
+from pdf_generator import create_pdf_document
+from word_generator import create_word_document
+from chart_generator import parse_embedded_chart_data, create_chart_from_data
+from table_of_content import generate_table_of_contents_after_content, add_table_of_contents_page
+from document_helpers import (
+    extract_business_name_from_content,
+    filter_empty_sections,
+    extract_subheadings,
+    remove_duplicate_headings
+)
+from grouped import (
+    parse_content_into_groups,
+    extract_key_phrases,
+    get_content_groups_info
+)
+from markdown_renderer import (
+    clean_text_for_pdf,
+    render_markdown_to_pdf,
+    render_markdown_to_pdf_grouped,
+    render_markdown_to_docx,
+    render_markdown_to_docx_grouped,
+    clean_text_for_docx
+)
+
+__all__ = [
+    'create_pdf_document',
+    'create_word_document',
+    'parse_embedded_chart_data',
+    'create_chart_from_data',
+    'generate_table_of_contents_after_content',
+    'add_table_of_contents_page',
+    'extract_business_name_from_content',
+    'filter_empty_sections',
+    'extract_subheadings',
+    'parse_content_into_groups',
+    'extract_key_phrases',
+    'get_content_groups_info',
+    'remove_duplicate_headings',
+    'clean_text_for_pdf',
+    'render_markdown_to_pdf',
+    'render_markdown_to_pdf_grouped',
+    'render_markdown_to_docx',
+    'render_markdown_to_docx_grouped',
+    'clean_text_for_docx'
+]

app/DocumentGeneration/chart_generator.py

@@ -0,0 +1,384 @@
+# Chart Generator Module
+# Contains parse_embedded_chart_data() and create_chart_from_data() functions
+
+import re
+import io
+import os
+import sys
+import base64
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from typing import List, Dict, Any, Optional
+
+# Add the parent directory to sys.path to import from models.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportSection
+
+def parse_embedded_chart_data(sections: List[ExportSection]) -> List[Dict[str, Any]]:
+    """Parse chart data embedded in section content using CHARTDATA markers"""
+    charts = []
+    
+    for section in sections:
+        if section.content:
+            # Look for chart data markers - handle both formats
+            chart_matches = re.findall(r'<!--CHART_DATA_START-->(.*?)<!--CHART_DATA_END-->', section.content, re.DOTALL)
+            
+            # Also check for alternative markers as fallback
+            alt_chart_matches = re.findall(r'<!--CHARTDATASTART-->(.*?)<!--CHARTDATAEND-->', section.content, re.DOTALL)
+            chart_matches.extend(alt_chart_matches)
+            
+            # logging.info(f"Section '{section.title}': Found {len(chart_matches)} chart data markers")
+            
+            for chart_data in chart_matches:
+                try:
+                    # Parse the chart data array
+                    chart_array = eval(chart_data.strip())
+                    # logging.info(f"Parsed chart array with {len(chart_array)} items")
+                    # logging.info(f"Chart array type: {type(chart_array)}")
+                    
+                    # Each chart is an array with: [Section, ChartType, Title, Period, Data]
+                    for chart_item in chart_array:
+                        if len(chart_item) >= 5:
+                            section_name = chart_item[0]
+                            chart_type = chart_item[1]  # DC=Doughnut, BG=Bar Graph, etc.
+                            chart_title = chart_item[2]
+                            period = chart_item[3]
+                            data = chart_item[4]
+                            
+                            chart_info = {
+                                "section": section_name,
+                                "type": chart_type,
+                                "title": chart_title,
+                                "period": period,
+                                "data": data,
+                                "source_section": section.title
+                            }
+                            
+                            charts.append(chart_info)
+                            # logging.info(f"Added chart: {chart_type} - {chart_title} for section {section_name}")
+                        else:
+                            # logging.warning(f"Chart item has insufficient data: {len(chart_item)} items, expected 5")
+                            pass
+                
+                except Exception as e:
+                    # logging.error(f"Failed to parse chart data for section '{section.title}': {str(e)}")
+                    continue
+            
+            # Additional debugging: Check for any chart-related content
+            if not chart_matches:
+                # Look for any chart-related markers or text
+                chart_indicators = re.findall(r'<!--.*?CHART.*?-->', section.content, re.DOTALL)
+                if chart_indicators:
+                    # logging.info(f"Section '{section.title}': Found chart indicators: {chart_indicators}")
+                    pass
+                
+                # Check for general chart text
+                if 'CHART' in section.content.upper() or 'chart' in section.content.lower():
+                    # logging.info(f"Section '{section.title}': Contains chart-related text")
+                    pass
+    
+    # logging.info(f"Total charts parsed: {len(charts)}")
+    return charts
+
+def create_enhanced_chart_style(chart_type, data, title, business_idea):
+    """Create charts with enhanced professional styling"""
+    # Set modern style
+    plt.style.use('default')
+    
+    # Design palette from image
+    colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+    
+    if chart_type == "DC":  # Doughnut Chart
+        fig, ax = plt.subplots(figsize=(14, 10))
+        
+        # Extract labels and values from data
+        labels = [item[0] for item in data]
+        values = [item[1] for item in data]
+        
+        # Create doughnut chart with enhanced styling
+        wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                         autopct='%1.1f%%', startangle=90,
+                                         wedgeprops=dict(width=0.6, edgecolor='white', linewidth=2),
+                                         textprops={'fontsize': 18})
+        
+        # Enhanced title styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        
+        # Add legend with enhanced styling
+        legend = ax.legend(wedges, labels, title="Categories", 
+                          loc="center left", bbox_to_anchor=(1, 0, 0.5, 1),
+                          fontsize=16, title_fontsize=18)
+        legend.get_title().set_color('#FF6B6B')
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+        
+    elif chart_type == "BG":  # Bar Graph
+        fig, ax = plt.subplots(figsize=(16, 10))
+        
+        # Extract labels and values
+        labels = [item[0] for item in data]
+        values = [item[1] for item in data]
+        
+        # Create bar chart with enhanced styling
+        bars = ax.bar(labels, values, color=colors[:len(values)], 
+                     edgecolor='white', linewidth=1, alpha=0.8)
+        
+        # Add value labels on bars
+        for bar, value in zip(bars, values):
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2., height + max(values)*0.01,
+                   f'{value}', ha='center', va='bottom', fontweight='bold', fontsize=18)
+        
+        # Enhanced styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        ax.set_xlabel('Categories', fontsize=18, color='#6B7280')
+        ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+        
+        # Rotate x-axis labels for better readability
+        plt.setp(ax.get_xticklabels(), rotation=45, ha='right', fontsize=16)
+        plt.setp(ax.get_yticklabels(), fontsize=16)
+        
+        # Add grid for better readability
+        ax.yaxis.grid(True, alpha=0.3)
+        ax.set_axisbelow(True)
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+        
+    elif chart_type == "LG":  # Line Graph
+        fig, ax = plt.subplots(figsize=(16, 10))
+        
+        # Extract data
+        x_values = [item[0] for item in data]
+        y_values = [item[1] for item in data]
+        
+        # Create line chart with enhanced styling
+        ax.plot(x_values, y_values, color='#FF6B6B', linewidth=3, marker='o', 
+               markersize=8, markerfacecolor='white', markeredgecolor='#FF6B6B')
+        
+        # Fill area under line
+        ax.fill_between(x_values, y_values, alpha=0.3, color='#4ECDC4')
+        
+        # Enhanced styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        ax.set_xlabel('Time Period', fontsize=18, color='#6B7280')
+        ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+        
+        # Add grid
+        ax.grid(True, alpha=0.3)
+        ax.set_axisbelow(True)
+        
+        # Increase tick label font sizes
+        plt.setp(ax.get_xticklabels(), fontsize=16)
+        plt.setp(ax.get_yticklabels(), fontsize=16)
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+        
+    elif chart_type == "PG":  # Pie Graph
+        fig, ax = plt.subplots(figsize=(14, 10))
+        
+        # Extract labels and values
+        labels = [item[0] for item in data]
+        values = [item[1] for item in data]
+        
+        # Create pie chart with enhanced styling
+        wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                         autopct='%1.1f%%', startangle=90,
+                                         wedgeprops=dict(edgecolor='white', linewidth=2),
+                                         textprops={'fontsize': 18})
+        
+        # Enhanced title styling
+        ax.set_title(title, fontsize=24, fontweight='bold', pad=20, color='#374151')
+        
+        # Add business name watermark
+        fig.text(0.5, 0.02, f"Generated for: {business_idea}", 
+                ha='center', va='bottom', fontsize=8, color='#9CA3AF', style='italic')
+        
+        plt.tight_layout()
+        return fig
+    
+    return None
+
+def create_chart_from_data(chart_info: Dict[str, Any], business_idea: str) -> bytes:
+    """Create a matplotlib chart from parsed chart data with enhanced styling"""
+    try:
+        chart_type = chart_info["type"]
+        chart_title = chart_info["title"]
+        data = chart_info["data"]
+        
+        # logging.info(f"Creating chart: {chart_type} - {chart_title} with {len(data)} data points")
+        
+        # Use enhanced styling function
+        fig = create_enhanced_chart_style(chart_type, data, chart_title, business_idea)
+        
+        if fig is None:
+            # Fallback to original method if enhanced styling fails
+            if chart_type == "DC":  # Doughnut Chart
+                fig, ax = plt.subplots(figsize=(14, 10))  # Larger size for better visibility
+                
+                # Extract labels and values from data
+                labels = [item[0] for item in data]
+                values = [item[1] for item in data]
+                
+                # High contrast color scheme
+                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+                
+                # Create doughnut chart
+                wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                                 autopct='%1.1f%%', startangle=90,
+                                                 wedgeprops=dict(width=0.6, edgecolor='white', linewidth=2),
+                                                 textprops={'fontsize': 18})
+                
+                # Enhanced title
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                
+                # Add legend
+                ax.legend(wedges, labels, title="Categories", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1), fontsize=16)
+                
+                plt.tight_layout()
+            elif chart_type == "BG":  # Bar Graph
+                fig, ax = plt.subplots(figsize=(16, 10))
+                
+                # Extract labels and values
+                labels = [item[0] for item in data]
+                values = [item[1] for item in data]
+                
+                # High contrast color scheme
+                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+                
+                # Create bar chart
+                bars = ax.bar(labels, values, color=colors[:len(values)], 
+                             edgecolor='white', linewidth=1, alpha=0.8)
+                
+                # Add value labels on bars
+                for bar, value in zip(bars, values):
+                    height = bar.get_height()
+                    ax.text(bar.get_x() + bar.get_width()/2., height + max(values)*0.01,
+                           f'{value}', ha='center', va='bottom', fontweight='bold', fontsize=18)
+                
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                ax.set_xlabel('Categories', fontsize=18, color='#6B7280')
+                ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+                
+                # Rotate x-axis labels
+                plt.setp(ax.get_xticklabels(), rotation=45, ha='right', fontsize=16)
+                plt.setp(ax.get_yticklabels(), fontsize=16)
+                
+                # Add grid
+                ax.yaxis.grid(True, alpha=0.3)
+                ax.set_axisbelow(True)
+                
+                plt.tight_layout()
+            elif chart_type == "LG":  # Line Graph
+                fig, ax = plt.subplots(figsize=(16, 10))
+                
+                # Extract data
+                x_values = [item[0] for item in data]
+                y_values = [item[1] for item in data]
+                
+                # Create line chart
+                ax.plot(x_values, y_values, color='#FF6B6B', linewidth=3, marker='o', 
+                       markersize=8, markerfacecolor='white', markeredgecolor='#FF6B6B')
+                
+                # Fill area under line
+                ax.fill_between(x_values, y_values, alpha=0.3, color='#4ECDC4')
+                
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                ax.set_xlabel('Time Period', fontsize=18, color='#6B7280')
+                ax.set_ylabel('Values', fontsize=18, color='#6B7280')
+                
+                # Add grid
+                ax.grid(True, alpha=0.3)
+                ax.set_axisbelow(True)
+                
+                # Increase tick label font sizes
+                plt.setp(ax.get_xticklabels(), fontsize=16)
+                plt.setp(ax.get_yticklabels(), fontsize=16)
+                
+                plt.tight_layout()
+            elif chart_type == "PG":  # Pie Graph
+                fig, ax = plt.subplots(figsize=(14, 10))
+                
+                # Extract labels and values
+                labels = [item[0] for item in data]
+                values = [item[1] for item in data]
+                
+                # High contrast color scheme
+                colors = ['#6A2EAB', '#5A2E9B', '#C0C0C0', '#FF8C00', '#FFD700', '#696969', '#FF4500']
+                
+                # Create pie chart
+                wedges, texts, autotexts = ax.pie(values, labels=labels, colors=colors[:len(values)],
+                                                 autopct='%1.1f%%', startangle=90,
+                                                 wedgeprops=dict(edgecolor='white', linewidth=2),
+                                                 textprops={'fontsize': 18})
+                
+                ax.set_title(chart_title, fontsize=22, fontweight='bold', pad=15, color='#374151')
+                
+                plt.tight_layout()
+            else:
+                # logging.warning(f"Unknown chart type: {chart_type}")
+                return None
+        
+        # Save to bytes
+        buffer = io.BytesIO()
+        fig.savefig(buffer, format='png', dpi=300, bbox_inches='tight', 
+                   facecolor='white', edgecolor='none')
+        buffer.seek(0)
+        chart_bytes = buffer.getvalue()
+        buffer.close()
+        
+        # Close the figure to free memory
+        plt.close(fig)
+        
+        return chart_bytes
+        
+    except Exception as e:
+        # logging.error(f"Failed to create chart: {str(e)}")
+        return None
+
+def fix_base64_padding(base64_string: str) -> str:
+    """Fix common base64 padding issues"""
+    # Remove any whitespace or newlines
+    base64_string = base64_string.strip()
+    
+    # Add padding if needed
+    missing_padding = len(base64_string) % 4
+    if missing_padding:
+        base64_string += '=' * (4 - missing_padding)
+    
+    return base64_string
+
+def robust_base64_decode(base64_string: str) -> Optional[bytes]:
+    """Robustly decode base64 string with error handling and padding correction"""
+    try:
+        # First try direct decoding
+        return base64.b64decode(base64_string)
+    except Exception as e1:
+        try:
+            # Try with padding correction
+            fixed_string = fix_base64_padding(base64_string)
+            return base64.b64decode(fixed_string)
+        except Exception as e2:
+            try:
+                # Try with URL-safe base64
+                return base64.urlsafe_b64decode(fix_base64_padding(base64_string))
+            except Exception as e3:
+                try:
+                    # Try with standard base64 ignoring padding
+                    return base64.b64decode(base64_string + '==', validate=False)
+                except Exception as e4:
+                    return None

app/DocumentGeneration/document_helpers.py

@@ -0,0 +1,159 @@
+# Document Helper Functions
+# Contains helper functions like filter_empty_sections(), extract_business_name_from_content(), etc.
+
+import re
+import os
+import sys
+from typing import List, Dict, Any
+
+# Add the parent directory to sys.path to import from models.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportSection
+
+def extract_business_name_from_content(sections: List[ExportSection]) -> str:
+    """Extract business name from markdown content"""
+    for section in sections:
+        if section.content:
+            lines = section.content.split('\n')
+            for i, line in enumerate(lines):
+                line = line.strip()
+                # Look for "Business Name:" pattern
+                if '**Business Name:**' in line or 'Business Name:' in line:
+                    # Extract the business name from the line
+                    if '**Business Name:**' in line:
+                        business_name = line.split('**Business Name:**')[1].strip()
+                    else:
+                        business_name = line.split('Business Name:')[1].strip()
+                    
+                    # Keep markdown formatting - don't strip ** symbols
+                    # business_name = re.sub(r'[*_`~]', '', business_name)
+                    business_name = business_name.strip()
+                    
+                    if business_name:
+                        return business_name
+                    
+                    # If not found on same line, check next line
+                    if i + 1 < len(lines):
+                        next_line = lines[i + 1].strip()
+                        business_name = next_line  # Keep ** symbols
+                        business_name = business_name.strip()
+                        if business_name:
+                            return business_name
+    
+    return None
+
+def extract_subheadings(content: str) -> List[str]:
+    """Extract subheadings from markdown content"""
+    subheadings = []
+    lines = content.split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        # Look for various markdown header patterns
+        if (line.startswith('##') and not line.startswith('###')) or \
+           line.startswith('**') and line.endswith('**') and len(line) > 4:
+            # Remove markdown formatting and clean up
+            if line.startswith('##'):
+                subheading = re.sub(r'^##+\s*', '', line)
+            else:
+                # Handle bold text that might be headings - keep ** symbols
+                subheading = line  # Keep ** symbols instead of stripping them
+            
+            # subheading = re.sub(r'[*_`~]', '', subheading)  # Commented out to preserve ** symbols
+            if subheading.strip() and len(subheading.strip()) > 3:  # Avoid very short headings
+                subheadings.append(subheading.strip())
+    
+    return subheadings
+
+
+
+
+
+
+
+
+
+
+
+def filter_empty_sections(sections: List[ExportSection]) -> List[ExportSection]:
+    """Filter out sections with no content to prevent empty pages"""
+    filtered_sections = []
+    
+    for section in sections:
+        if section.content and section.content.strip():
+            # Clean the content to check if it's actually meaningful
+            cleaned_content = section.content # No clean_text_for_pdf import, so use raw content
+            if cleaned_content and len(cleaned_content.strip()) > 10:  # At least 10 characters
+                filtered_sections.append(section)
+                # logging.info(f"Section '{section.title}' passed filtering with {len(cleaned_content)} characters")
+            else:
+                # logging.info(f"Section '{section.title}' filtered out - content too short: {len(cleaned_content) if cleaned_content else 0} chars")
+                pass
+        else:
+            # logging.info(f"Section '{section.title}' filtered out - no content")
+            pass
+    
+    # logging.info(f"Filtered sections: {len(filtered_sections)} out of {len(sections)} total")
+    return filtered_sections
+
+
+def remove_duplicate_headings(content: str) -> str:
+    """Remove duplicate headings from content"""
+    if not content:
+        return content
+    
+    lines = content.split('\n')
+    cleaned_lines = []
+    seen_headings = set()
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            cleaned_lines.append('')
+            continue
+        
+        # Check if this is any type of heading
+        is_heading = False
+        heading_text = ""
+        
+        # Markdown headings (# ## ### etc.)
+        if line.startswith('#'):
+            heading_text = re.sub(r'^#+\s*', '', line).strip()
+            is_heading = True
+        
+        # Bold headings (**text**)
+        elif line.startswith('**') and line.endswith('**') and len(line) > 4:
+            heading_text = line[2:-2].strip()  # Remove ** symbols
+            is_heading = True
+        
+        # Check for numbered headings (e.g., "8.1 Management Team")
+        elif re.match(r'^\d+\.?\d*\s+', line):
+            heading_text = re.sub(r'^\d+\.?\d*\s+', '', line).strip()
+            is_heading = True
+        
+        if is_heading and heading_text:
+            # Normalize the heading text for comparison
+            normalized_text = heading_text.lower().strip()
+            
+            # Also check for variations with "and" vs "&"
+            variations = [
+                normalized_text,
+                normalized_text.replace(' & ', ' and '),
+                normalized_text.replace(' and ', ' & '),
+                normalized_text.replace('&', 'and'),
+                normalized_text.replace('and', '&')
+            ]
+            
+            # Check if any variation has been seen before
+            is_duplicate = any(var in seen_headings for var in variations)
+            
+            if not is_duplicate:
+                # Add all variations to seen set
+                for var in variations:
+                    seen_headings.add(var)
+                cleaned_lines.append(line)
+            # Skip duplicate headings
+        else:
+            cleaned_lines.append(line)
+    
+    return '\n'.join(cleaned_lines)

app/DocumentGeneration/grouped.py

@@ -0,0 +1,304 @@
+import re
+from typing import List, Dict, Any
+
+def calculate_group_height(pdf, group: Dict[str, Any]) -> int:
+    """Calculate the estimated height needed for a complete group"""
+    subheading_type = group['subheading_type']
+    content_lines = group['content'].split('\n') if group['content'] else []
+    
+    # Base height for subheading
+    if subheading_type == 'h1':
+        subheading_height = 25  # 20pt font + spacing
+    elif subheading_type == 'h2':
+        subheading_height = 20  # 16pt font + underline + spacing
+    elif subheading_type == 'h3':
+        subheading_height = 16  # 14pt font + spacing
+    elif subheading_type == 'h4':
+        subheading_height = 14  # 12pt font + spacing
+    elif subheading_type == 'bold':
+        subheading_height = 20  # 16pt font + spacing
+    elif subheading_type == 'numbered':
+        subheading_height = 20  # 16pt font + spacing
+    else:
+        subheading_height = 16
+    
+    # Calculate content height more accurately
+    content_height = 0
+    for line in content_lines:
+        if line.strip():
+            # More accurate line height calculation
+            words = line.split()
+            if len(words) > 0:
+                # Estimate characters per line (roughly 80-90 chars per line)
+                chars_per_line = 85
+                estimated_lines = max(1, len(line) // chars_per_line + 1)
+                line_height = estimated_lines * 8  # 8pt per line
+                content_height += line_height
+            else:
+                content_height += 8  # Empty line
+        else:
+            content_height += 3  # Empty line spacing
+    
+    # Add spacing between groups
+    group_spacing = 8
+    
+    total_height = subheading_height + content_height + group_spacing
+    
+    print(f"DEBUG: Group '{group.get('subheading_clean', 'Unknown')[:30]}...' height calculation:")
+    print(f"  Subheading height: {subheading_height}")
+    print(f"  Content height: {content_height}")
+    print(f"  Group spacing: {group_spacing}")
+    print(f"  Total height: {total_height}")
+    
+    return total_height
+
+def should_break_page_for_group(pdf, group: Dict[str, Any], current_y: int, page_height: int = 280) -> bool:
+    """Determine if we should break to a new page for this group"""
+    estimated_height = calculate_group_height(pdf, group)
+    
+    print(f"DEBUG: should_break_page_for_group called")
+    print(f"DEBUG:   Subheading: '{group.get('subheading_clean', 'Unknown')[:30]}...'")
+    print(f"DEBUG:   Current Y: {current_y}")
+    print(f"DEBUG:   Estimated height: {estimated_height}")
+    print(f"DEBUG:   Page height: {page_height}")
+    print(f"DEBUG:   Available space: {page_height - current_y}")
+    print(f"DEBUG:   Will fit? {current_y + estimated_height <= page_height}")
+    
+    # CRITICAL FIX: Only break if the group absolutely won't fit
+    # This prevents splitting subheadings from their content
+    
+    # If the group won't fit on current page, break
+    if current_y + estimated_height > page_height:
+        print(f"DEBUG:   -> BREAKING: Group won't fit ({current_y} + {estimated_height} > {page_height})")
+        return True
+    
+    # If we're very close to the end of the page (less than 50mm remaining) and group is significant, break
+    if current_y > page_height - 50 and estimated_height > 30:
+        print(f"DEBUG:   -> BREAKING: Very close to end of page ({current_y} > {page_height - 50}) and group significant ({estimated_height} > 30)")
+        return True
+    
+    print(f"DEBUG:   -> NO BREAK: Group will fit on current page")
+    return False
+
+def clean_markdown_from_line(line: str) -> str:
+    """Clean markdown formatting from a single line"""
+    if not line:
+        return ""
+    
+    cleaned = line
+    
+    # Remove bold, italic formatting
+    cleaned = re.sub(r'\*\*(.*?)\*\*', r'\1', cleaned)  # Remove bold
+    cleaned = re.sub(r'\*(.*?)\*', r'\1', cleaned)  # Remove italic
+    cleaned = re.sub(r'`(.*?)`', r'\1', cleaned)  # Remove code
+    cleaned = re.sub(r'~~(.*?)~~', r'\1', cleaned)  # Remove strikethrough
+    
+    # Remove emphasis markers
+    cleaned = re.sub(r'_{1,2}(.*?)_{1,2}', r'\1', cleaned)  # Remove underscores
+    cleaned = re.sub(r'\*{1,2}(.*?)\*{1,2}', r'\1', cleaned)  # Remove asterisks
+    
+    # Remove links (keep text)
+    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)  # Remove links, keep text
+    
+    # Remove any remaining HTML-like tags
+    cleaned = re.sub(r'<[^>]+>', '', cleaned)
+    
+    # CRITICAL FIX: Replace multiple spaces with single space to prevent double spaces
+    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
+    
+    return cleaned.strip()
+
+def parse_content_into_groups(content: str) -> List[Dict[str, Any]]:
+    """Parse markdown content into subheading-content groups"""
+    if not content:
+        return []
+    
+    print(f"DEBUG: parse_content_into_groups called with content length: {len(content)}")
+    
+    lines = content.split('\n')
+    groups = []
+    current_group = None
+    
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if not line:
+            if current_group:
+                current_group['content_lines'].append('')  # Preserve empty lines
+            continue
+        
+        # Check if this is a heading (H1, H2, H3, H4, or numbered)
+        is_heading = (
+            line.startswith('# ') or  # H1
+            (line.startswith('## ') and not line.startswith('### ')) or  # H2
+            (line.startswith('### ') and not line.startswith('#### ')) or  # H3
+            (line.startswith('#### ') and not line.startswith('##### ')) or  # H4
+            re.match(r'^\d+\.\d+\s+', line)  # Numbered subheadings like "3.6 SWOT Analysis"
+        )
+        
+        # Check if this is bold text
+        is_bold_text = (
+            (line.startswith('**') and line.endswith('**') and len(line) > 4) or  # Bold headings
+            (re.match(r'^\*\*.*?\*\*:', line) and len(line) > 4)  # Bold text before colon as heading
+        )
+
+        # Check if this is a bold list item (e.g., "- **Item**")
+        is_bold_list_item = re.match(r'^[-*]\s*\*\*(.*?)\*\*$', line)
+        
+        # Special handling for bold text following numbered subheadings
+        should_create_new_group = False
+        
+        if is_heading:
+            # Always create new group for regular headings
+            should_create_new_group = True
+            print(f"DEBUG: Line {i+1} '{line[:50]}...' - Regular heading, creating new group")
+        elif is_bold_text:
+            # Check if we should treat this bold text as content for a numbered subheading
+            if groups and groups[-1].get('subheading_type') == 'h3':
+                # Check if the previous group's subheading looks like a numbered subheading
+                previous_subheading = groups[-1].get('subheading', '')
+                if re.match(r'^\d+\.\d+\s+', previous_subheading):
+                    # This is content for a numbered subheading, add to previous group
+                    groups[-1]['content_lines'].append(line)
+                    print(f"DEBUG: Line {i+1} '{line[:50]}...' - Adding to previous numbered subheading '{previous_subheading[:30]}...'")
+                    continue  # Skip creating new group
+                else:
+                    # Not a numbered subheading, treat as new heading
+                    should_create_new_group = True
+                    print(f"DEBUG: Line {i+1} '{line[:50]}...' - Treating as NEW HEADING (not numbered subheading)")
+            else:
+                # No previous group or not a numbered subheading, treat as new heading
+                should_create_new_group = True
+                print(f"DEBUG: Line {i+1} '{line[:50]}...' - Treating as NEW HEADING (no numbered subheading)")
+        elif is_bold_list_item:
+            # If it's a bold list item, treat it as a new heading
+            should_create_new_group = True
+            print(f"DEBUG: Line {i+1} '{line[:50]}...' - Bold list item, creating new group")
+        
+        if should_create_new_group:
+            # Save previous group if it exists
+            if current_group:
+                current_group['content'] = '\n'.join(current_group['content_lines'])
+                groups.append(current_group)
+                print(f"DEBUG: Saved group '{current_group.get('subheading_clean', 'Unknown')[:30]}...' with {len(current_group['content_lines'])} content lines")
+            
+            # Clean markdown symbols BEFORE determining type and storing
+            clean_text = line
+            heading_type = 'text'
+            
+            if line.startswith('# '):
+                clean_text = line[2:].strip()  # Remove "# "
+                heading_type = 'h1'
+            elif line.startswith('## '):
+                clean_text = line[3:].strip()  # Remove "## "
+                heading_type = 'h2'
+            elif line.startswith('### '):
+                clean_text = line[4:].strip()  # Remove "### "
+                heading_type = 'h3'
+            elif line.startswith('#### '):
+                clean_text = line[5:].strip()  # Remove "#### "
+                heading_type = 'h4'
+            elif re.match(r'^\d+\.\d+\s+', line):
+                clean_text = line.strip()  # Keep numbered headings as-is
+                heading_type = 'numbered'
+            elif is_bold_text:
+                # Remove ** markers from bold text
+                clean_text = clean_markdown_from_line(line.strip())
+                heading_type = 'bold'
+            elif is_bold_list_item:
+                # Extract the bold text from list item and treat as H3 subheading
+                # Remove the list marker and ** markers
+                clean_text = re.sub(r'^[-*]\s*\*\*(.*?)\*\*', r'\1', line.strip())
+                heading_type = 'h3'  # Treat as H3 subheading
+            
+            print(f"DEBUG: Creating new group '{clean_text[:30]}...' (type: {heading_type})")
+            
+            # Start new group with cleaned text
+            current_group = {
+                'subheading': line,  # Keep original for reference
+                'content_lines': [],
+                'content': '',
+                'subheading_clean': clean_text,  # Pre-cleaned text
+                'subheading_type': heading_type
+            }
+        else:
+            # Add to current group's content - clean the line
+            if current_group:
+                cleaned_line = clean_markdown_from_line(line)
+                current_group['content_lines'].append(cleaned_line)
+                if i < 5:  # Log first few content lines
+                    print(f"DEBUG: Added content line to group '{current_group.get('subheading_clean', 'Unknown')[:30]}...': '{cleaned_line[:50]}...'")
+            else:
+                # Content before any subheading - create a default group
+                if not groups or groups[-1].get('subheading') != '## Introduction':
+                    cleaned_line = clean_markdown_from_line(line)
+                    current_group = {
+                        'subheading': '## Introduction',
+                        'content_lines': [cleaned_line],
+                        'content': '',
+                        'subheading_clean': 'Introduction',
+                        'subheading_type': 'h2'
+                    }
+    
+    # Don't forget the last group
+    if current_group:
+        current_group['content'] = '\n'.join(current_group['content_lines'])
+        groups.append(current_group)
+        print(f"DEBUG: Saved final group '{current_group.get('subheading_clean', 'Unknown')[:30]}...' with {len(current_group['content_lines'])} content lines")
+    
+    # Add metadata to each group
+    for i, group in enumerate(groups):
+        group['group_id'] = f"group_{i}"
+        group['content_length'] = len(group['content'])
+        group['word_count'] = len(group['content'].split()) if group['content'] else 0
+        group['has_charts'] = 'CHART' in group['content'].upper() if group['content'] else False
+        group['line_count'] = len([line for line in group['content'].split('\n') if line.strip()])
+    
+    print(f"DEBUG: Created {len(groups)} groups total")
+    return groups
+
+def extract_key_phrases(content: str) -> List[tuple]:
+    """Extract key phrases from content for grouping metadata"""
+    if not content:
+        return []
+    
+    # Simple key phrase extraction
+    words = re.findall(r'\b\w+\b', content.lower())
+    word_freq = {}
+    
+    for word in words:
+        if len(word) > 3:  # Only words longer than 3 characters
+            word_freq[word] = word_freq.get(word, 0) + 1
+    
+    # Return top 5 most frequent words
+    return sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
+
+def get_content_groups_info(content: str) -> Dict[str, Any]:
+    """Get detailed information about content groups for analysis and debugging"""
+    if not content:
+        return {"groups": [], "summary": {"total_groups": 0, "total_content_length": 0}}
+    
+    groups = parse_content_into_groups(content)
+    
+    # Add key phrases to each group
+    for group in groups:
+        group['key_phrases'] = extract_key_phrases(group['content'])
+    
+    # Calculate summary statistics
+    total_content_length = sum(group['content_length'] for group in groups)
+    total_word_count = sum(group['word_count'] for group in groups)
+    groups_with_charts = sum(1 for group in groups if group['has_charts'])
+    
+    summary = {
+        "total_groups": len(groups),
+        "total_content_length": total_content_length,
+        "total_word_count": total_word_count,
+        "groups_with_charts": groups_with_charts,
+        "average_group_size": total_content_length / len(groups) if groups else 0,
+        "largest_group": max(groups, key=lambda g: g['content_length'])['subheading_clean'] if groups else None,
+        "smallest_group": min(groups, key=lambda g: g['content_length'])['subheading_clean'] if groups else None
+    }
+    
+    return {
+        "groups": groups,
+        "summary": summary
+    }

app/DocumentGeneration/live_pdf_generator.py

@@ -0,0 +1,126 @@
+# Live PDF Generator Module
+# Enables real-time PDF updates as content changes
+
+import asyncio
+import io
+import tempfile
+import os
+from typing import Dict, Any, Optional, AsyncGenerator
+from fpdf import FPDF
+import base64
+
+import sys
+import os
+sys.path.append(os.path.dirname(__file__))
+from pdf_generator import create_pdf_document
+from models import ExportRequest
+
+class LivePDFGenerator:
+    """Generates and streams PDF updates in real-time"""
+    
+    def __init__(self):
+        self.active_sessions: Dict[str, 'PDFSession'] = {}
+    
+    async def create_live_session(self, business_plan_id: str, initial_request: ExportRequest) -> str:
+        """Create a new live PDF session"""
+        session_id = f"pdf_session_{business_plan_id}_{int(asyncio.get_event_loop().time())}"
+        
+        session = PDFSession(session_id, business_plan_id, initial_request)
+        self.active_sessions[session_id] = session
+        
+        # Generate initial PDF
+        await session.update_pdf(initial_request)
+        
+        return session_id
+    
+    async def update_session(self, session_id: str, updated_request: ExportRequest) -> bool:
+        """Update an existing PDF session with new content"""
+        if session_id not in self.active_sessions:
+            return False
+        
+        session = self.active_sessions[session_id]
+        await session.update_pdf(updated_request)
+        return True
+    
+    async def stream_pdf_updates(self, session_id: str) -> AsyncGenerator[bytes, None]:
+        """Stream PDF updates as they occur"""
+        if session_id not in self.active_sessions:
+            return
+        
+        session = self.active_sessions[session_id]
+        async for pdf_chunk in session.stream_updates():
+            yield pdf_chunk
+    
+    def close_session(self, session_id: str):
+        """Close and cleanup a PDF session"""
+        if session_id in self.active_sessions:
+            del self.active_sessions[session_id]
+
+class PDFSession:
+    """Individual PDF session that manages real-time updates"""
+    
+    def __init__(self, session_id: str, business_plan_id: str, initial_request: ExportRequest):
+        self.session_id = session_id
+        self.business_plan_id = business_plan_id
+        self.current_request = initial_request
+        self.update_queue = asyncio.Queue()
+        self.is_active = True
+        self.last_pdf_bytes: Optional[bytes] = None
+        
+    async def update_pdf(self, new_request: ExportRequest):
+        """Update the PDF with new content"""
+        self.current_request = new_request
+        
+        try:
+            # Generate new PDF
+            pdf_bytes, filename = create_pdf_document(new_request)
+            self.last_pdf_bytes = pdf_bytes
+            
+            # Notify subscribers of update
+            await self.update_queue.put({
+                'type': 'pdf_update',
+                'data': base64.b64encode(pdf_bytes).decode('utf-8'),
+                'filename': filename,
+                'timestamp': asyncio.get_event_loop().time()
+            })
+            
+        except Exception as e:
+            # Notify subscribers of error
+            await self.update_queue.put({
+                'type': 'pdf_error',
+                'error': str(e),
+                'timestamp': asyncio.get_event_loop().time()
+            })
+    
+    async def stream_updates(self) -> AsyncGenerator[bytes, None]:
+        """Stream PDF updates as they occur"""
+        while self.is_active:
+            try:
+                # Wait for updates with timeout
+                update = await asyncio.wait_for(self.update_queue.get(), timeout=30.0)
+                
+                if update['type'] == 'pdf_update':
+                    # Send SSE event for PDF update
+                    event_data = f"event: pdf_update\ndata: {{\"data\": \"{update['data']}\", \"filename\": \"{update['filename']}\"}}\n\n"
+                    yield event_data.encode('utf-8')
+                    
+                elif update['type'] == 'pdf_error':
+                    # Send SSE event for error
+                    error_data = f"event: pdf_error\ndata: {{\"error\": \"{update['error']}\"}}\n\n"
+                    yield error_data.encode('utf-8')
+                    
+            except asyncio.TimeoutError:
+                # Send keep-alive
+                yield b": keep-alive\n\n"
+            except Exception as e:
+                # Send error event
+                error_data = f"event: stream_error\ndata: {str(e)}\n\n"
+                yield error_data.encode('utf-8')
+                break
+    
+    def close(self):
+        """Close this session"""
+        self.is_active = False
+
+# Global instance
+live_pdf_generator = LivePDFGenerator()

app/DocumentGeneration/markdown_renderer.py

@@ -0,0 +1,759 @@
+# Markdown Renderer Module
+# Contains all markdown rendering functions for both PDF and Word
+
+import re
+import base64
+import os
+import sys
+import tempfile
+from typing import List, Dict, Any, Optional
+
+# Import from the same directory (Document Generation)
+from grouped import parse_content_into_groups, should_break_page_for_group
+from chart_generator import create_chart_from_data
+
+def clean_markdown_text(text: str) -> str:
+    """Clean markdown formatting for PDF generation - PRESERVE HEADINGS"""
+    if not text:
+        return ""
+    
+    # Remove markdown formatting BUT PRESERVE HEADING STRUCTURE
+    cleaned = text
+    
+    # PRESERVE HEADINGS - don't strip the # markers, keep them for rendering
+    # We'll handle styling at render time instead of stripping them
+    
+    # Remove bold, italic formatting - strip ** or * symbols
+    cleaned = re.sub(r'\*\*(.*?)\*\*', r'\1', cleaned)  # Remove bold
+    cleaned = re.sub(r'\*(.*?)\*', r'\1', cleaned)  # Remove italic
+    cleaned = re.sub(r'`(.*?)`', r'\1', cleaned)  # Remove code
+    cleaned = re.sub(r'~~(.*?)~~', r'\1', cleaned)  # Remove strikethrough
+    
+    # Remove links (keep text)
+    cleaned = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', cleaned)  # Remove links, keep text
+    cleaned = re.sub(r'!\[([^\]]*)\]\([^)]+\)', '', cleaned)  # Remove images
+    
+    # Remove list markers (more aggressive)
+    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove list markers
+    cleaned = re.sub(r'^\s*\d+\.\s*', '', cleaned, flags=re.MULTILINE)  # Remove numbered list markers
+    cleaned = re.sub(r'^\s*[-*+]\s*', '', cleaned, flags=re.MULTILINE)  # Remove any remaining list markers
+    
+    # Remove blockquotes
+    cleaned = re.sub(r'^\s*>\s*', '', cleaned, flags=re.MULTILINE)  # Remove blockquotes
+    
+    # Remove horizontal rules
+    cleaned = re.sub(r'^\s*[-*_]{3,}\s*$', '', cleaned, flags=re.MULTILINE)  # Remove horizontal rules
+    
+    # Remove code blocks
+    cleaned = re.sub(r'```[\s\S]*?```', '', cleaned)  # Remove code blocks
+    cleaned = re.sub(r'`.*?`', '', cleaned)  # Remove any remaining inline code
+    
+    # Remove emphasis markers - strip ** or * symbols
+    cleaned = re.sub(r'_{1,2}(.*?)_{1,2}', r'\1', cleaned)  # Remove underscores
+    cleaned = re.sub(r'\*{1,2}(.*?)\*{1,2}', r'\1', cleaned)  # Remove asterisks
+    
+    # PRESERVE CHART DATA MARKERS for inline processing
+    # DO NOT REMOVE chart markers - they will be processed inline
+    # cleaned = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', cleaned, flags=re.DOTALL)
+    # cleaned = re.sub(r'<!--CHARTDATASTART-->.*$', '', cleaned, flags=re.DOTALL)
+    # cleaned = re.sub(r'<!--CHARTDATAEND-->', '', cleaned)
+    
+    # REMOVE CHART DATA MARKERS for PDF rendering since they're not being processed
+    cleaned = re.sub(r'<!--CHART_DATA_START-->.*?<!--CHART_DATA_END-->', '', cleaned, flags=re.DOTALL)
+    cleaned = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', cleaned, flags=re.DOTALL)
+    
+    # Remove any remaining HTML-like tags
+    cleaned = re.sub(r'<[^>]+>', '', cleaned)
+    
+    # Clean up extra whitespace and formatting
+    cleaned = re.sub(r'\n\s*\n\s*\n+', '\n\n', cleaned)  # Remove excessive line breaks
+    cleaned = re.sub(r'^\s+', '', cleaned, flags=re.MULTILINE)  # Remove leading whitespace
+    cleaned = re.sub(r'\s+$', '', cleaned, flags=re.MULTILINE)  # Remove trailing whitespace
+    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
+    
+    # Final cleanup
+    cleaned = cleaned.strip()
+    
+    return cleaned
+
+def clean_text_for_pdf(text: str) -> str:
+    """Clean text specifically for PDF generation, handling Unicode issues"""
+    if not text:
+        return ""
+    
+    # First clean markdown
+    cleaned = clean_markdown_text(text)
+    
+    # Replace problematic Unicode characters with ASCII equivalents
+    unicode_replacements = {
+        '\u2019': "'",  # Right single quotation mark
+        '\u2018': "'",  # Left single quotation mark
+        '\u201C': '"',  # Left double quotation mark
+        '\u201D': '"',  # Right double quotation mark
+        '\u2013': '-',  # En dash
+        '\u2014': '--', # Em dash
+        '\u2022': '•',  # Bullet
+        '\u2026': '...', # Horizontal ellipsis
+        '\u00A0': ' ',  # Non-breaking space
+        '\u00B0': '°',  # Degree sign
+        '\u00AE': '(R)', # Registered trademark
+        '\u2122': '(TM)', # Trademark
+        '\u00A9': '(C)', # Copyright
+    }
+    
+    for unicode_char, replacement in unicode_replacements.items():
+        cleaned = cleaned.replace(unicode_char, replacement)
+
+    # Additional space normalization after Unicode replacements to prevent double spaces
+    cleaned = re.sub(r' +', ' ', cleaned)  # Replace multiple spaces with single space
+    
+    return cleaned
+
+def process_content_with_inline_charts(doc, content: str, business_idea: str):
+    """Process content and render charts inline where they appear in the text"""
+    try:
+        from docx.shared import Inches
+    except ImportError:
+        raise Exception("python-docx is not installed. Please install it with: pip install python-docx")
+    
+    # Split content by chart markers - handle both formats
+    chart_pattern = r'<!--CHART_DATA_START-->(.*?)<!--CHART_DATA_END-->'
+    parts = re.split(chart_pattern, content, flags=re.DOTALL)
+    
+    # If no charts found, try alternative format
+    if len(parts) == 1:
+        chart_pattern = r'<!--CHARTDATASTART-->(.*?)<!--CHARTDATAEND-->'
+        parts = re.split(chart_pattern, content, flags=re.DOTALL)
+    
+    for i, part in enumerate(parts):
+        if i % 2 == 0:  # Regular content
+            if part.strip():
+                render_markdown_to_docx_grouped(doc, part.strip())
+        else:  # Chart data
+            try:
+                chart_array = eval(part.strip())
+                for chart_item in chart_array:
+                    if len(chart_item) >= 5:
+                        chart_type = chart_item[1]
+                        chart_title = chart_item[2]
+                        data = chart_item[4]
+                        
+                        # Add chart title
+                        doc.add_heading(f"{chart_title}", level=2)
+                        
+                        # Create and add chart
+                        chart_info = {
+                            "type": chart_type,
+                            "title": chart_title,
+                            "data": data
+                        }
+                        
+                        chart_bytes = create_chart_from_data(chart_info, business_idea)
+                        
+                        if chart_bytes:
+                            with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
+                                tmp_img.write(chart_bytes)
+                                temp_img_path = tmp_img.name
+                            
+                            # Add image to Word document
+                            doc.add_picture(temp_img_path, width=Inches(6.0))  # 6 inches width
+                            
+                            # Clean up temp file
+                            os.remove(temp_img_path)
+            except Exception as e:
+                # If chart processing fails, just render the raw content
+                if part.strip():
+                    render_markdown_to_docx_grouped(doc, part.strip())
+
+
+def render_markdown_to_pdf(pdf, content: str, primary_color, accent_color, text_color):
+    """Render markdown content to PDF with proper heading styling and page break logic"""
+    if not content:
+        return
+    
+    lines = content.split('\n')
+    current_y = pdf.get_y()
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            # Check if we need a page break for empty line
+            if current_y + 10 > 280:  # 280mm is roughly where we want to break
+                pdf.add_page()
+                current_y = 25
+            else:
+                pdf.ln(3)  # Consistent space for empty lines
+                current_y = pdf.get_y()
+            continue
+        
+        # Calculate estimated height needed for this line
+        estimated_height = 12  # Base height for text
+        
+        # Handle different heading levels
+        if line.startswith("# "):    # H1 - Main heading (like "Company Profile")
+            estimated_height = 25  # Heading + line + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line[2:].strip()
+            pdf.set_font("Arial", "B", 20)  # Bold, size 20
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 10, text)
+            
+            # Calculate text width and make line autofit
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
+            
+            # Add subtle line under main heading - consistent with section titles
+            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
+            pdf.set_line_width(0.3)  # Thin line
+            pdf.line(25, current_y + 10, 25 + line_width, current_y + 10)
+            
+            current_y = pdf.get_y()
+            pdf.ln(8)  # Consistent space after main heading
+            current_y = pdf.get_y()
+            
+        elif line.startswith("## ") or re.match(r'^\d+\.\d+\s+', line):   # H2 - Subheading or numbered subheading
+            estimated_height = 20  # Subheading + line + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line[3:].strip() if line.startswith("## ") else line.strip()
+            pdf.set_font("Arial", "B", 16)  # Bold, size 16
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+            
+            # Calculate text width and make line autofit
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 10, 160)  # Add 10mm padding, max 160mm
+            
+            # Add subtle line under subheading - consistent styling
+            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
+            pdf.set_line_width(0.3)  # Thin line
+            pdf.line(25, current_y + 8, 25 + line_width, current_y + 8)
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Consistent space after subheading
+            current_y = pdf.get_y()
+            
+        elif re.match(r'^\d+\.\d+\s+[A-Z]', line):  # Numbered subheadings like "3.6 SWOT Analysis"
+            estimated_height = 20  # Subheading + line + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line.strip()
+            pdf.set_font("Arial", "B", 16)  # Bold, size 16
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Consistent space after subheading
+            current_y = pdf.get_y()
+            
+        elif line.startswith("### ") or line.startswith("#### "):  # H3/H4 - Smaller subheadings
+            estimated_height = 18  # Subheading + spacing
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            text = line[4:].strip() if line.startswith("### ") else line[5:].strip()
+            pdf.set_font("Arial", "B", 14)  # Bold, size 14
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+            
+            current_y = pdf.get_y()
+            pdf.ln(4)  # Consistent space after subheading
+            current_y = pdf.get_y()
+            
+        elif line.startswith("**") and line.endswith("**"):  # Bold text that might be a heading
+            text = line.strip()  # Keep ** markers
+            # Check if this looks like a main heading (no numbers, not too long)
+            if not re.match(r'^\d+\.', text) and len(text) < 50:
+                estimated_height = 22  # Heading + line + spacing
+                if current_y + estimated_height > 280:
+                    pdf.add_page()
+                    current_y = 25
+                
+                pdf.set_font("Arial", "B", 18)  # Bold, size 18
+                pdf.set_text_color(*primary_color)  # Black
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 9, text)
+                
+                current_y = pdf.get_y()
+                pdf.ln(6)  # Consistent space after heading
+                current_y = pdf.get_y()
+            else:
+                # Regular bold text
+                estimated_height = 12
+                if current_y + estimated_height > 280:
+                    pdf.add_page()
+                    current_y = 25
+                
+                pdf.set_font("Arial", "B", 12)  # Bold, size 12
+                pdf.set_text_color(*text_color)  # Dark gray
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 8, text)
+                current_y = pdf.get_y()
+            
+        else:  # Normal paragraph text
+            # For long paragraphs, estimate height based on text length
+            estimated_height = max(12, len(line) // 80 * 12)  # Rough estimate
+            if current_y + estimated_height > 280:
+                pdf.add_page()
+                current_y = 25
+            
+            pdf.set_font("Arial", "", 12)  # Regular font, size 12
+            pdf.set_text_color(*text_color)  # Dark gray
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+            current_y = pdf.get_y()
+
+
+def render_markdown_to_pdf_grouped(pdf, content: str, primary_color, accent_color, text_color):
+    """Render markdown content to PDF with subheading-content grouping and smart page breaks"""
+    if not content:
+        return
+    
+    print(f"DEBUG: render_markdown_to_pdf_grouped called with content length: {len(content)}")
+    print(f"DEBUG: FULL CONTENT:")
+    print("=" * 80)
+    print(content)
+    print("=" * 80)
+    
+    # Parse content into groups
+    groups = parse_content_into_groups(content)
+    
+    for group in groups:
+        subheading = group['subheading']
+        group_content = group['content']
+        subheading_type = group['subheading_type']
+        
+        # Get current Y position from PDF
+        current_y = pdf.get_y()
+        page_height = 280  # Approximate usable page height
+        
+        # Use smart page break logic
+        if should_break_page_for_group(pdf, group, current_y, page_height):
+            pdf.add_page()
+            current_y = 25
+            pdf.set_y(current_y)  # Set the PDF's Y position
+        
+        # Render subheading based on type - using original styling
+        # Use the pre-cleaned text from the group
+        text = group['subheading_clean']
+        
+        if subheading_type == 'h1':
+            pdf.set_font("Arial", "B", 20)  # Bold, size 20 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 10, text)
+            
+            # Calculate text width and make line autofit
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
+            
+            # Add subtle line under main heading - consistent with section titles
+            pdf.set_draw_color(221, 221, 221)  # Lighter gray line (#DDDDDD)
+            pdf.set_line_width(0.3)  # Thin line
+            pdf.line(25, current_y + 10, 25 + line_width, current_y + 10)
+            
+            current_y = pdf.get_y()
+            pdf.ln(8)  # Consistent space after main heading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'h2':
+            pdf.set_font("Arial", "B", 18)  # Bold, size 18 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 9, text)
+            
+            # Add underline (original styling)
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)
+            pdf.set_draw_color(221, 221, 221)  # Light gray line
+            pdf.set_line_width(0.3)
+            pdf.line(25, current_y + 9, 25 + line_width, current_y + 9)
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Space after subheading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'h3':
+            pdf.set_font("Arial", "B", 14)  # Bold, size 14 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 8, text)
+            
+            current_y = pdf.get_y()
+            pdf.ln(4)  # Space after subheading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'h4':
+            pdf.set_font("Arial", "B", 12)  # Bold, size 12 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 7, text)
+            
+            current_y = pdf.get_y()
+            pdf.ln(3)  # Space after subheading
+            current_y = pdf.get_y()
+            
+        elif subheading_type == 'bold':
+            line_height_heading = 9 # For size 18 heading
+            line_height_text = 8 # For size 12 text
+            
+            if not re.match(r'^\d+\.', text) and len(text) < 80:
+                # Main heading style
+                pdf.set_font("Arial", "B", 12) # Bold, size 12
+                pdf.set_text_color(*primary_color) # Black
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 8, text) # Multi-cell for text
+                current_y = pdf.get_y() # Get updated Y position
+                pdf.ln(6)
+                current_y = pdf.get_y()
+            else:
+                # Regular bold text
+                pdf.set_font("Arial", "B", 12) # Bold, size 12
+                pdf.set_text_color(*text_color) # Dark gray
+                pdf.set_xy(25, current_y)
+                pdf.multi_cell(160, 8, text) # Multi-cell for text
+                current_y = pdf.get_y() # Get updated Y position
+            
+        elif subheading_type == 'numbered':
+            pdf.set_font("Arial", "B", 18)  # Bold, size 18 (original size)
+            pdf.set_text_color(*primary_color)  # Black
+            pdf.set_xy(25, current_y)
+            pdf.multi_cell(160, 9, text)
+            
+            # Add underline (original styling)
+            text_width = pdf.get_string_width(text)
+            line_width = min(text_width + 12, 160)
+            pdf.set_draw_color(221, 221, 221)  # Light gray line
+            pdf.set_line_width(0.3)
+            pdf.line(25, current_y + 9, 25 + line_width, current_y + 9)
+            
+            current_y = pdf.get_y()
+            pdf.ln(6)  # Space after subheading
+            current_y = pdf.get_y()
+        
+        # Render grouped content with simple styling
+        if group_content:
+            content_lines = group_content.split('\n')
+            for line in content_lines:
+                if line.strip():
+                    # Check if line contains text ending with ":" that should be bold
+                    if ':' in line:
+                        # Split the line by ":" to separate the label from the content
+                        parts = line.split(':', 1)  # Split only on first ":"
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Render label in bold
+                            pdf.set_font("Arial", "B", 12)  # Bold
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, label + ":")
+                            current_y = pdf.get_y()
+                            
+                            # Render content in regular font
+                            if content:
+                                pdf.set_font("Arial", "", 12)  # Regular
+                                pdf.set_text_color(*text_color)
+                                pdf.set_xy(25, current_y)
+                                pdf.multi_cell(160, 8, content, align='L')  # Left align to prevent text justification
+                                current_y = pdf.get_y()
+                        else:
+                            # No content after ":", just render the whole line
+                            pdf.set_font("Arial", "B", 12)  # Bold for labels ending with ":"
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+                            current_y = pdf.get_y()
+                    elif ' - ' in line:
+                        # Split the line by " - " to separate the label from the content
+                        parts = line.split(' - ', 1)  # Split only on first " - "
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Render label in bold
+                            pdf.set_font("Arial", "B", 12)  # Bold
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, label + " -")
+                            current_y = pdf.get_y()
+                            
+                            # Render content in regular font
+                            if content:
+                                pdf.set_font("Arial", "", 12)  # Regular
+                                pdf.set_text_color(*text_color)
+                                pdf.set_xy(25, current_y)
+                                pdf.multi_cell(160, 8, content, align='L')  # Left align to prevent text justification
+                                current_y = pdf.get_y()
+                        else:
+                            # No content after " - ", just render the whole line
+                            pdf.set_font("Arial", "B", 12)  # Bold for labels ending with " -"
+                            pdf.set_text_color(*text_color)
+                            pdf.set_xy(25, current_y)
+                            pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+                            current_y = pdf.get_y()
+                    else:
+                        # Regular paragraph rendering without mixed text processing
+                        pdf.set_font("Arial", "", 12)
+                        pdf.set_text_color(*text_color)
+                        pdf.set_xy(25, current_y)
+                        pdf.multi_cell(160, 8, line, align='L')  # Left align to prevent text justification
+                        current_y = pdf.get_y()  # Update current_y after each line
+                else:
+                    # Empty line spacing
+                    pdf.ln(3)
+                    current_y = pdf.get_y()  # Update current_y after spacing
+
+
+def render_markdown_to_docx(doc, content: str):
+    """Render markdown content to Word document with proper heading styling"""
+    if not content:
+        return
+    
+    lines = content.split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            doc.add_paragraph()  # Empty paragraph for spacing
+            continue
+        
+        # Handle different heading levels
+        if line.startswith("# "):    # H1 - Main heading (like "Company Profile")
+            text = line[2:].strip()
+            doc.add_heading(text, level=1)
+        elif line.startswith("## ") or re.match(r'^\d+\.\d+\s+', line):   # H2 - Subheading or numbered subheading
+            text = line[3:].strip() if line.startswith("## ") else line.strip()
+            doc.add_heading(text, level=2)
+        elif re.match(r'^\d+\.\d+\s+[A-Z]', line):  # Numbered subheadings like "3.6 SWOT Analysis"
+            text = line.strip()
+            doc.add_heading(text, level=2)
+        elif line.startswith("### ") or line.startswith("#### "):  # H3/H4 - Smaller subheadings
+            text = line[4:].strip() if line.startswith("### ") else line[5:].strip()
+            doc.add_heading(text, level=3)
+        elif line.startswith("**") and line.endswith("**"):  # Bold text that might be a heading
+            text = line.strip()  # Keep ** markers
+            # Check if this looks like a main heading (no numbers, not too long)
+            if not re.match(r'^\d+\.', text) and len(text) < 50:
+                doc.add_heading(text, level=1)  # Treat as main heading
+            else:
+                # Regular bold text
+                doc.add_paragraph(text)
+        else:  # Normal paragraph text
+            # Check if line contains text ending with ":" that should be bold
+            if ':' in line:
+                # Split the line by ":" to separate the label from the content
+                parts = line.split(':', 1)  # Split only on first ":"
+                if len(parts) == 2:
+                    label = parts[0].strip()
+                    content = parts[1].strip()
+                    
+                    # Create paragraph with mixed formatting
+                    paragraph = doc.add_paragraph()
+                    # Add label in bold
+                    run = paragraph.add_run(label + ":")
+                    run.bold = True
+                    # Add content in regular font
+                    if content:
+                        run = paragraph.add_run(" " + content)
+                        run.bold = False
+                else:
+                    # No content after ":", just render the whole line in bold
+                    paragraph = doc.add_paragraph(line)
+                    paragraph.runs[0].bold = True
+            elif ' - ' in line:
+                # Split the line by " - " to separate the label from the content
+                parts = line.split(' - ', 1)  # Split only on first " - "
+                if len(parts) == 2:
+                    label = parts[0].strip()
+                    content = parts[1].strip()
+                    
+                    # Create paragraph with mixed formatting
+                    paragraph = doc.add_paragraph()
+                    # Add label in bold
+                    run = paragraph.add_run(label + " -")
+                    run.bold = True
+                    # Add content in regular font
+                    if content:
+                        run = paragraph.add_run(" " + content)
+                        run.bold = False
+                else:
+                    # No content after " - ", just render the whole line in bold
+                    paragraph = doc.add_paragraph(line)
+                    paragraph.runs[0].bold = True
+            else:
+                doc.add_paragraph(line)
+
+
+def render_markdown_to_docx_grouped(doc, content: str):
+    """Render markdown content to Word document with subheading-content grouping and smart page breaks"""
+    if not content:
+        return
+    
+    # Parse content into groups
+    groups = parse_content_into_groups(content)
+    
+    for i, group in enumerate(groups):
+        subheading = group['subheading']
+        group_content = group['content']
+        subheading_type = group['subheading_type']
+        
+        # Add page break before group if it's not the first group and the previous group was large
+        if i > 0:
+            # Check if we should add a page break to keep groups together
+            # This is a simple heuristic - in Word, we rely more on the natural flow
+            # but we can add manual page breaks for very large groups
+            if group['content_length'] > 1000:  # Large group threshold
+                doc.add_page_break()
+        
+        # Render subheading based on type - using original styling
+        # Use the pre-cleaned text from the group
+        text = group['subheading_clean']
+        
+        if subheading_type == 'h1':
+            doc.add_heading(text, level=1)
+        elif subheading_type == 'h2':
+            doc.add_heading(text, level=2)
+        elif subheading_type == 'h3':
+            doc.add_heading(text, level=3)
+        elif subheading_type == 'h4':
+            doc.add_heading(text, level=4)
+        elif subheading_type == 'bold':
+            if not re.match(r'^\d+\.', text) and len(text) < 80:
+                # Simple paragraph with bold text
+                paragraph = doc.add_paragraph(text)
+                paragraph.style = doc.styles['Heading 1'] # Apply heading style
+            else:
+                # Regular paragraph
+                doc.add_paragraph(text)
+        elif subheading_type == 'numbered':
+            doc.add_heading(text, level=2)
+        
+        # Render grouped content with simple styling
+        if group_content:
+            content_lines = group_content.split('\n')
+            for line in content_lines:
+                if line.strip():
+                    # Check if line contains text ending with ":" that should be bold
+                    if ':' in line:
+                        # Split the line by ":" to separate the label from the content
+                        parts = line.split(':', 1)  # Split only on first ":"
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Create paragraph with mixed formatting
+                            paragraph = doc.add_paragraph()
+                            # Add label in bold
+                            run = paragraph.add_run(label + ":")
+                            run.bold = True
+                            # Add content in regular font
+                            if content:
+                                run = paragraph.add_run(" " + content)
+                                run.bold = False
+                        else:
+                            # No content after ":", just render the whole line in bold
+                            paragraph = doc.add_paragraph(line)
+                            paragraph.runs[0].bold = True
+                    elif ' - ' in line:
+                        # Split the line by " - " to separate the label from the content
+                        parts = line.split(' - ', 1)  # Split only on first " - "
+                        if len(parts) == 2:
+                            label = parts[0].strip()
+                            content = parts[1].strip()
+                            
+                            # Create paragraph with mixed formatting
+                            paragraph = doc.add_paragraph()
+                            # Add label in bold
+                            run = paragraph.add_run(label + " -")
+                            run.bold = True
+                            # Add content in regular font
+                            if content:
+                                run = paragraph.add_run(" " + content)
+                                run.bold = False
+                        else:
+                            # No content after " - ", just render the whole line in bold
+                            paragraph = doc.add_paragraph(line)
+                            paragraph.runs[0].bold = True
+                    else:
+                        # Simple paragraph addition without mixed text processing
+                        doc.add_paragraph(line)
+                else:
+                    doc.add_paragraph()  # Empty paragraph for spacing
+
+
+
+def clean_text_for_docx(text: str) -> str:
+    # Replace problematic Unicode characters with ASCII equivalents
+    unicode_replacements = {
+        '\u2019': "'",  # Right single quotation mark
+        '\u2018': "'",  # Left single quotation mark
+        '\u201C': '"',  # Left double quotation mark
+        '\u201D': '"',  # Right double quotation mark
+        '\u2013': '-',  # En dash
+        '\u2014': '--', # Em dash
+        '\u2022': '•',  # Bullet
+        '\u2026': '...', # Horizontal ellipsis
+        '\u00A0': ' ',  # Non-breaking space
+        '\u00B0': '°',  # Degree sign
+        '\u00AE': '(R)', # Registered trademark
+        '\u2122': '(TM)', # Trademark
+        '\u00A9': '(C)', # Copyright
+    }
+    
+    for unicode_char, replacement in unicode_replacements.items():
+        text = text.replace(unicode_char, replacement)
+    
+    # Simple text cleaning - keep basic punctuation and common symbols
+    text = ''.join(char for char in text if ord(char) < 128 or char in '•°$€£¥₹₩₽₪₺₴₼₸₾֏₲₡₣₦₵₨₱₫₭៛৳؋﷼%')
+    
+    return text
+
+
+
+
+
+
+
+
+
+def clean_unicode_for_pdf(text: str) -> str:
+    # Replace problematic Unicode characters with ASCII equivalents
+    unicode_replacements = {
+        '\u2019': "'",  # Right single quotation mark
+        '\u2018': "'",  # Left single quotation mark
+        '\u201C': '"',  # Left double quotation mark
+        '\u201D': '"',  # Right double quotation mark
+        '\u2013': '-',  # En dash
+        '\u2014': '--', # Em dash
+        '\u2022': '•',  # Bullet
+        '\u2026': '...', # Horizontal ellipsis
+        '\u00A0': ' ',  # Non-breaking space
+        '\u00B0': '°',  # Degree sign
+        '\u00AE': '(R)', # Registered trademark
+        '\u2122': '(TM)', # Trademark
+        '\u00A9': '(C)', # Copyright
+    }
+    
+    for unicode_char, replacement in unicode_replacements.items():
+        text = text.replace(unicode_char, replacement)
+    
+    # Simple text cleaning - keep basic punctuation and common symbols
+    text = ''.join(char for char in text if ord(char) < 128 or char in '•°$€£¥₹₩₽₪₺₴₼₸₾֏₲₡₣₦₵₨₱₫₭៛৳؋﷼%')
+    
+    return text
+

app/DocumentGeneration/mixed.py

@@ -0,0 +1,6 @@
+# This file has been removed as all its functions are not present in maintest.txt
+# Functions removed:
+# - make_sentences_ending_with_colon_bold()
+# - _render_mixed_text_to_pdf()
+# - clean_bold_text_for_pdf()
+# - process_bold_text_for_docx()

app/DocumentGeneration/pdf_generator.py

@@ -0,0 +1,682 @@
+# PDF Generator Module
+# Contains create_pdf_document() and all PDF-related functions
+
+import re
+import os
+import tempfile
+import time
+import sys
+from typing import List, Dict, Any
+
+# Add the parent directory to sys.path to import from models.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportRequest
+
+# Import from the same directory (Document Generation)
+from document_helpers import (
+    filter_empty_sections,
+    extract_business_name_from_content,
+    remove_duplicate_headings
+)
+from table_of_content import generate_table_of_contents_after_content, add_table_of_contents_page
+from chart_generator import parse_embedded_chart_data, create_chart_from_data
+from markdown_renderer import (
+    clean_text_for_pdf,
+    render_markdown_to_pdf_grouped
+)
+
+# Add Currency Mapping path
+currency_mapping_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'Currency Mapping')
+if currency_mapping_path not in sys.path:
+    sys.path.append(currency_mapping_path)
+from CurrencyMapping.currency_mapping import convert_currency_symbols_to_iso
+
+# Import sort_sections_by_order from utils module
+from utils import sort_sections_by_order
+
+def calculate_real_page_numbers(request: ExportRequest, filtered_sections):
+    """Calculate real page numbers by creating a temporary PDF with all content INCLUDING charts"""
+    try:
+        from fpdf import FPDF
+    except ImportError:
+        raise Exception("fpdf2 is not installed. Please install it with: pip install fpdf2")
+    
+    # Create temporary PDF to calculate page numbers
+    temp_pdf = FPDF()
+    temp_pdf.set_auto_page_break(auto=True, margin=15)
+    
+    # Add cover page
+    temp_pdf.add_page()
+    
+    # Add TOC page (placeholder)
+    temp_pdf.add_page()
+    
+    # Parse charts from embedded chart data in section content
+    embedded_charts = parse_embedded_chart_data(filtered_sections)
+    
+    # Create charts and map them to sections
+    chart_info_map = {}
+    if embedded_charts:
+        for chart_info in embedded_charts:
+            chart_bytes = create_chart_from_data(chart_info, request.businessIdea or "Business")
+            if chart_bytes:
+                source_section = chart_info["source_section"]
+                if source_section not in chart_info_map:
+                    chart_info_map[source_section] = []
+                chart_info_map[source_section].append({
+                    "chart_bytes": chart_bytes,
+                    "title": chart_info["title"],
+                    "type": chart_info["type"]
+                })
+    
+    # Add all sections to calculate real page numbers INCLUDING charts
+    section_page_map = {}
+    sorted_sections = sort_sections_by_order(filtered_sections)
+    
+    for section in sorted_sections:
+        temp_pdf.add_page()
+        current_page = temp_pdf.page_no()
+        section_page_map[section.title] = current_page
+        
+        # Don't add section title manually - let the markdown content handle headings
+        
+        # Add section content
+        temp_pdf.set_font("Arial", "", 12)
+        temp_pdf.set_text_color(51, 51, 51)
+        temp_pdf.set_xy(25, temp_pdf.get_y())
+        
+        # Process content
+        try:
+            content_text = clean_text_for_pdf(section.content)
+        except Exception as e:
+            content_text = section.content or ""
+        
+        # Remove chart data markers
+        content_text = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', content_text, flags=re.DOTALL)
+        content_text = re.sub(r'<!--CHARTDATASTART-->.*$', '', content_text, flags=re.DOTALL)
+        
+        # No need to filter section titles since we're not adding them manually
+        
+        # Add content with proper markdown rendering
+        if content_text and content_text.strip():
+            render_markdown_to_pdf_grouped(temp_pdf, content_text, (0,0,0), (75,0,130), (51,51,51))
+        
+        # Add charts for this section (same logic as in actual PDF generation)
+        section_charts = chart_info_map.get(section.title, [])
+        
+        # Try different matching strategies for charts
+        if not section_charts:
+            # Case-insensitive match
+            for chart_source, charts in chart_info_map.items():
+                if chart_source.lower() == section.title.lower():
+                    section_charts = charts
+                    break
+            
+            # Partial match
+            if not section_charts:
+                for chart_source, charts in chart_info_map.items():
+                    if (section.title.lower() in chart_source.lower() or 
+                        chart_source.lower() in section.title.lower()):
+                        section_charts = charts
+                        break
+            
+            # Key-based match
+            if not section_charts and hasattr(section, 'key'):
+                for chart_source, charts in chart_info_map.items():
+                    if section.key and section.key.replace('prompt_', '') in chart_source.lower():
+                        section_charts = charts
+                        break
+        
+        # Add charts with same page break logic as actual PDF
+        if section_charts:
+            charts_per_page = 0
+            max_charts_per_page = 5
+            
+            for chart_info in section_charts:
+                try:
+                    chart_height_needed = 140  # Chart height (120) + title (20) + minimal spacing
+                    current_y = temp_pdf.get_y()
+                    charts_per_page += 1
+                    
+                    # Only force page break if absolutely necessary
+                    if (current_y + chart_height_needed > 290) or (charts_per_page > 5):
+                        temp_pdf.add_page()
+                        y_title = 25
+                        charts_per_page = 1
+                    else:
+                        y_title = current_y
+                    
+                    # Add minimal spacing before chart if not at top of page
+                    if y_title > 25:
+                        temp_pdf.ln(3)
+                    
+                    # Chart title is already included in the chart itself, no need for separate title
+                    
+                    # Add chart image
+                    img_width = 160  # Much larger chart width
+                    x = (210 - img_width) / 2
+                    y_img = y_title
+                    
+                    # Save image to temp file
+                    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
+                        tmp_img.write(chart_info["chart_bytes"])
+                        temp_img_path = tmp_img.name
+                    
+                    # Add chart
+                    chart_height = 120  # Much larger chart height
+                    temp_pdf.image(temp_img_path, x=x, y=y_img, w=img_width)
+                    temp_pdf.ln(chart_height + 5)
+                    
+                    # Clean up temp file
+                    try:
+                        os.remove(temp_img_path)
+                    except Exception:
+                        pass
+                        
+                except Exception:
+                    # Skip faulty chart and continue
+                    continue
+    
+    return section_page_map
+
+def create_pdf_document(request: ExportRequest):
+    """Create a PROFESSIONAL PDF document from the business plan data using FPDF2
+    NOTE: Now uses matplotlib charts exclusively - old base64 chart logic commented out"""
+    try:
+        from fpdf import FPDF
+    except ImportError:
+        raise Exception("fpdf2 is not installed. Please install it with: pip install fpdf2")
+    
+    # Filter out empty sections to prevent blank pages
+    try:
+        filtered_sections = filter_empty_sections(request.sections)
+    except Exception as e:
+        raise Exception(f"Failed to filter sections: {str(e)}")
+    if not filtered_sections:
+        raise Exception("No valid sections found after filtering. All sections appear to be empty.")
+    
+    # First pass: Calculate real page numbers by creating a temporary PDF
+    section_page_map = calculate_real_page_numbers(request, filtered_sections)
+    
+    # Generate TOC with real page numbers
+    toc_items = generate_table_of_contents_after_content(filtered_sections, section_page_map, request.businessIdea)
+    
+    # Second pass: Create final PDF with TOC on page 2
+    pdf = FPDF()
+    pdf.set_auto_page_break(auto=True, margin=15)  # Reduced margin to allow more charts per page
+    
+    # Add confidentiality footer to every page
+    def add_confidentiality_footer(pdf):
+        pdf.set_font("Arial", "", 8)
+        pdf.set_text_color(100, 100, 100)  # Gray text
+        pdf.set_y(-15)  # 15mm from bottom
+        pdf.cell(0, 5, "CONFIDENTIAL - This document contains proprietary information and may not be shared without consent", 0, 0, 'C')
+    
+    # Override the footer method
+    pdf.footer = lambda: add_confidentiality_footer(pdf)
+    pdf.add_page()
+    
+    # Professional color scheme - Refined for bank/investor presentation
+    primary_color = (0, 0, 0)        # Black - for headings
+    accent_color = (75, 0, 130)      # Navy purple - for accent lines and highlights
+    text_color = (51, 51, 51)        # Dark gray - for body text
+    light_gray = (221, 221, 221)     # Lighter gray - for subtle lines (#DDDDDD)
+    navy_color = (25, 25, 112)       # Navy blue - for TOC and emphasis
+    
+    # Professional fonts - Arial for body, optional serif for main titles
+    title_font = 'Arial'  # Keep Arial for consistency
+    body_font = 'Arial'   # Modern business feel
+    
+    # Helper functions for consistent styling
+    def add_header(pdf, text, size=24, y_offset=25, primary_color=(0,0,0), accent_color=(75,0,130)):
+        pdf.set_font("Arial", "B", size)
+        pdf.set_text_color(*primary_color)
+        pdf.set_xy(25, y_offset)
+        pdf.cell(0, 18, text, ln=True)
+        
+        # Calculate text width and make line autofit
+        text_width = pdf.get_string_width(text)
+        line_width = min(text_width + 10, 160)  # Add 10mm padding, max 160mm (page width - margins)
+        
+        # Removed purple accent line
+        return y_offset + 25
+
+    def add_subheader(pdf, text, size=16, y_offset=None, primary_color=(0,0,0)):
+        if y_offset is None:
+            y_offset = pdf.get_y() + 10
+        pdf.set_font("Arial", "B", size)
+        pdf.set_text_color(*primary_color)
+        pdf.set_xy(25, y_offset)
+        pdf.cell(0, 14, text, ln=True)
+        
+        # Calculate text width and make line autofit
+        text_width = pdf.get_string_width(text)
+        line_width = min(text_width + 8, 160)  # Add 8mm padding, max 160mm (page width - margins)
+        
+        pdf.set_draw_color(221, 221, 221)  # Lighter gray (#DDDDDD) for subtle lines
+        pdf.set_line_width(0.3)  # Thinner line
+        pdf.line(25, y_offset + 14, 25 + line_width, y_offset + 14)
+        return y_offset + 20
+
+    def add_body_text(pdf, text, y_offset=None, text_color=(51,51,51)):
+        if y_offset is None:
+            y_offset = pdf.get_y() + 5
+        pdf.set_font("Arial", "", 12)
+        pdf.set_text_color(*text_color)
+        pdf.set_xy(25, y_offset)
+        pdf.multi_cell(160, 8, text, align='L')  # Left align to prevent text justification
+        return pdf.get_y()
+
+    def check_page_break(pdf, required_height=120, bottom_margin=300):
+        """Check if we need a page break and return the Y position to use"""
+        y = pdf.get_y()
+        if y + required_height > bottom_margin:
+            pdf.add_page()
+            return 25
+        return y
+
+    # ===== COVER PAGE =====
+    def add_cover_page():
+        # Clean white background - no purple background
+        
+        # Add company logo at the top
+        try:
+            # Use the MBD logo PNG file
+            project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            logo_path = os.path.join(project_root, 'assets', 'logos', 'MBD logo.png')
+            
+            if os.path.exists(logo_path):
+                # Add logo to PDF (centered, top of page) - LOGO FIRST, THEN TITLE BELOW
+                # Center the logo: (210 - 70) / 2 = 70, so logo starts at x=70
+                pdf.image(logo_path, x=70, y=20, w=70)  # Even larger size to show full logo
+                print(f"Logo added successfully from: {logo_path}")
+            else:
+                print(f"Logo file not found at: {logo_path}")
+        except Exception as e:
+            # Log any errors with logo
+            print(f"Logo error: {e}")
+            pass
+        
+        # Extract business name from content, fallback to businessIdea
+        extracted_business_name = extract_business_name_from_content(filtered_sections)
+        business_name = extracted_business_name or request.businessIdea or "Business Plan"
+        
+        # Company/Project name - DARK TEXT (moved down below logo)
+        pdf.set_font(title_font, "B", 32)
+        pdf.set_text_color(0, 0, 0)  # Black text for visibility on white background
+        pdf.ln(60)  # More space to move title below logo
+        pdf.cell(0, 25, business_name, ln=True, align='C')
+        
+        # Subtitle - DARK GRAY, BOLD, NO ITALICS
+        pdf.set_font(title_font, "B", 16)  # Reduced from 18pt, removed italics
+        pdf.set_text_color(51, 51, 51)  # Dark gray for visibility on white background
+        pdf.cell(0, 12, "Business Plan", ln=True, align='C')
+        
+        # Add some space
+        pdf.ln(40)
+    
+        
+        pdf.set_font(body_font, "", 12)
+        pdf.set_text_color(51, 51, 51)  # Dark text for content
+        pdf.set_xy(35, 145)
+        pdf.cell(0, 8, f"Created: {time.strftime('%B %d, %Y')}", ln=True)
+        pdf.set_xy(35, 153)
+        pdf.cell(0, 8, f"Format: {request.format.upper()}", ln=True)
+        pdf.set_xy(35, 161)
+        pdf.cell(0, 8, f"Sections: {len(request.sections)}", ln=True)
+        
+        # Footer - simple footer since confidentiality is now in page footer
+        pdf.set_font(body_font, "", 10)
+        pdf.set_text_color(51, 51, 51)  # Dark gray text for visibility on white background
+        pdf.set_xy(0, 280)
+        pdf.cell(0, 8, "Business Plan Document", ln=True, align='C')
+    
+
+    
+    # ===== SECTION PAGES =====
+    def add_sections_with_charts():
+        # Parse charts from embedded chart data in section content
+        embedded_charts = parse_embedded_chart_data(filtered_sections)
+        
+        if embedded_charts:
+            # Create actual charts from the parsed data
+            matplotlib_charts = []
+            chart_info_map = {}  # Map section names to their charts
+            
+            # logging.info(f"Chart info map keys: {list(chart_info_map.keys())}")
+            
+            for chart_info in embedded_charts:
+                chart_bytes = create_chart_from_data(chart_info, request.businessIdea or "Business")
+                if chart_bytes:
+                    matplotlib_charts.append(chart_bytes)
+                    # Map this chart to its source section
+                    source_section = chart_info["source_section"]
+                    # logging.info(f"Chart '{chart_info['title']}' has source_section: '{source_section}'")
+                    
+                    if source_section not in chart_info_map:
+                        chart_info_map[source_section] = []
+                    chart_info_map[source_section].append({
+                        "chart_bytes": chart_bytes,
+                        "title": chart_info["title"],
+                        "type": chart_info["type"]
+                    })
+                    # logging.info(f"Mapping chart '{chart_info['title']}' to source section: '{source_section}'")
+                    
+                    # CRITICAL DEBUG: Show the exact mapping being created
+                    # logging.info(f"  -> Chart '{chart_info['title']}' mapped to key '{source_section}' in chart_info_map")
+                else:
+                    pass
+            
+            # logging.info(f"Total charts created: {len(matplotlib_charts)}")
+            # logging.info(f"Final chart_info_map: {chart_info_map}")
+            
+            # Debug: Show all chart mappings
+            for source_section, charts in chart_info_map.items():
+                # logging.info(f"Source section '{source_section}' has {len(charts)} charts:")
+                for chart in charts:
+                    # logging.info(f"  - {chart['title']} ({chart['type']})")
+                    pass
+        
+        else:
+            matplotlib_charts = []
+            chart_info_map = {}
+        
+        total_charts_placed = 0
+        
+        # Sort sections according to predefined order
+        sorted_sections = sort_sections_by_order(filtered_sections)
+        # logging.info(f"Section titles in sorted order: {[s.title for s in sorted_sections]}")
+        
+        # CRITICAL DEBUG: Show exact section titles and their keys
+        for i, section in enumerate(sorted_sections):
+            # logging.info(f"Section {i+1}: '{section.title}' (key: {getattr(section, 'key', 'NO_KEY')})")
+            pass
+        
+        for i, section in enumerate(sorted_sections):
+            
+            # Always start each section on a new page
+            pdf.add_page()
+            
+            # Don't add section title manually - let the markdown content handle headings
+            
+            # Section content (properly positioned)
+            pdf.set_font(body_font, "", 12)
+            pdf.set_text_color(*text_color)
+            pdf.set_xy(25, pdf.get_y())  # Use current Y position for consistent spacing
+            
+            # Process content
+            try:
+                content_text = clean_text_for_pdf(section.content)
+            except Exception as e:
+                content_text = section.content or ""
+            try:
+                content_text = convert_currency_symbols_to_iso(content_text)
+            except Exception:
+                # If currency conversion fails, keep original text
+                pass
+            
+            # Remove chart data markers
+            content_text = re.sub(r'<!--CHARTDATASTART-->.*?<!--CHARTDATAEND-->', '', content_text, flags=re.DOTALL)
+            content_text = re.sub(r'<!--CHARTDATASTART-->.*$', '', content_text, flags=re.DOTALL)
+            
+            # Remove chart titles from content to prevent duplicate headings
+            # Get chart titles for this section
+            section_charts = chart_info_map.get(section.title, [])
+            if not section_charts:
+                # Try case-insensitive match
+                for chart_source, charts in chart_info_map.items():
+                    if chart_source.lower() == section.title.lower():
+                        section_charts = charts
+                        break
+            
+            # Remove chart titles from content
+            for chart_info in section_charts:
+                chart_title = chart_info["title"]
+                # Remove various markdown heading formats for the chart title
+                patterns_to_remove = [
+                    rf'^#+\s*{re.escape(chart_title)}\s*$',  # # Title, ## Title, etc.
+                    rf'^\*\*{re.escape(chart_title)}\*\*\s*$',  # **Title**
+                    rf'^{re.escape(chart_title)}\s*$',  # Just the title
+                ]
+                for pattern in patterns_to_remove:
+                    content_text = re.sub(pattern, '', content_text, flags=re.MULTILINE | re.IGNORECASE)
+            
+            # No need to filter section titles since we're not adding them manually
+            
+            # Skip enhance_subheadings_with_bold for grouped rendering to preserve ** markers
+            # content_text = enhance_subheadings_with_bold(content_text)
+            content_text = remove_duplicate_headings(content_text)
+            
+            # Add content with proper markdown rendering using grouped approach
+            if content_text and content_text.strip():
+                render_markdown_to_pdf_grouped(pdf, content_text, primary_color, accent_color, text_color)
+            else:
+                # Add placeholder text to prevent blank page
+                pdf.multi_cell(160, 8, f"Content for {section.title} section is being processed...", align='L')
+                
+            # Add visual separation between content and charts
+            if content_text and content_text.strip():
+                pdf.ln(15)  # More generous spacing for better visual separation
+            
+            # ---- Charts for this section ----
+            charts_added = 0  # IMPORTANT: initialize to avoid NameError
+
+            # CRITICAL DEBUG: Show exactly what charts exist and their source_section values
+            if section.title == "Financial Plan & Funding":
+                # logging.info(f"=== LAST SECTION DEBUG ===")
+                # logging.info(f"Section title: '{section.title}'")
+                # logging.info(f"All chart_info_map keys: {list(chart_info_map.keys())}")
+                for key, charts in chart_info_map.items():
+                    # logging.info(f"  Key '{key}' has {len(charts)} charts")
+                    for chart in charts:
+                        # logging.info(f"    Chart: {chart['title']} ({chart['type']})")
+                        pass
+                # logging.info(f"=== END LAST SECTION DEBUG ===")
+                pass
+            
+            section_charts = chart_info_map.get(section.title, [])
+            # logging.info(f"Section '{section.title}': Direct lookup found {len(section_charts)} charts")
+            
+            # Strategy 1: Exact title match
+            if not section_charts:
+                # logging.info(f"No exact match found for '{section.title}'")
+                pass
+                
+                # Strategy 2: Case-insensitive match
+                for chart_source, charts in chart_info_map.items():
+                    if chart_source.lower() == section.title.lower():
+                        section_charts = charts
+                        # logging.info(f"Found charts via case-insensitive match: '{chart_source}' -> {len(charts)} charts")
+                        break
+                
+                # Strategy 3: Partial match
+                if not section_charts:
+                    for chart_source, charts in chart_info_map.items():
+                        if (section.title.lower() in chart_source.lower() or 
+                            chart_source.lower() in section.title.lower()):
+                            section_charts = charts
+                            # logging.info(f"Found charts via partial match: '{chart_source}' -> {len(charts)} charts")
+                            break
+                
+                # Strategy 4: Key-based match (for prompt_ prefixed sections)
+                if not section_charts and hasattr(section, 'key'):
+                    for chart_source, charts in chart_info_map.items():
+                        if section.key and section.key.replace('prompt_', '') in chart_source.lower():
+                            section_charts = charts
+                            # logging.info(f"Found charts via key match: '{section.key}' -> '{chart_source}' -> {len(charts)} charts")
+                            break
+            
+            # logging.info(f"Section '{section.title}': Final chart count: {len(section_charts)}")
+
+            if section_charts:
+                
+                # Group charts that can fit on the same page
+                charts_per_page = 0
+                max_charts_per_page = 5  # Allow up to 5 charts per page
+                
+                for chart_info in section_charts:
+                    try:
+                        # Check if we need a new page for this chart
+                        chart_height_needed = 140  # Chart height (120) + title (20) + minimal spacing
+                        
+                        # Smart page break logic - allow multiple charts per page
+                        current_y = pdf.get_y()
+                        charts_per_page += 1
+                        
+                        # Only force page break if absolutely necessary - allow up to 5 charts per page
+                        if (current_y + chart_height_needed > 290) or (charts_per_page > 5):
+                            pdf.add_page()
+                            # Header/footer removed for now
+                            y_title = 25  # Start at normal position
+                            charts_per_page = 1  # Reset counter for new page
+                        else:
+                            y_title = current_y
+                        
+                        # Add minimal spacing before chart if not at top of page
+                        if y_title > 25:  # If not at top of page, add minimal space
+                            pdf.ln(3)  # Minimal spacing to fit more charts per page
+                        
+                        # Chart title is already included in the chart itself, no need for separate subheader
+
+                        # Centered image with larger dimensions for better visibility
+                        img_width = 160  # Much larger chart width for better visibility
+                        x = (210 - img_width) / 2
+                        y_img = y_title
+
+                        # Save image to temp file
+                        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
+                            tmp_img.write(chart_info["chart_bytes"])
+                            temp_img_path = tmp_img.name
+
+                        # Chart dimensions (no border needed)
+                        chart_height = 120  # Much larger height for better visibility
+                        chart_width = img_width
+
+                        # Image
+                        pdf.image(temp_img_path, x=x, y=y_img, w=chart_width)
+
+                        # Move below image and clean up (spacing based on actual chart height)
+                        pdf.ln(chart_height + 5)  # Chart height (120) + minimal spacing between charts
+                        try:
+                            os.remove(temp_img_path)
+                        except Exception:
+                            pass
+
+                        charts_added += 1
+                        total_charts_placed += 1
+                    except Exception:
+                        # Skip faulty chart and continue rendering others
+                        continue
+            else:
+                # Debug: Check if there are any charts that might match this section
+                potential_matches = []
+                for chart_source, charts in chart_info_map.items():
+                    if (section.title.lower() in chart_source.lower() or 
+                        chart_source.lower() in section.title.lower()):
+                        potential_matches.append(f"'{chart_source}' -> {len(charts)} charts")
+                
+                if potential_matches:
+                    # logging.info(f"Section '{section.title}': Potential chart matches: {potential_matches}")
+                    pass
+                else:
+                    # logging.info(f"Section '{section.title}': No charts found and no potential matches")
+                    pass
+            
+            # Each section is already on its own page, no need for complex page break logic
+        
+
+    
+    
+    # ===== BUILD THE PDF =====
+    try:
+        # Add all sections
+        try:
+            add_cover_page()
+        except Exception as e:
+            raise Exception(f"Cover page failed: {str(e)}")
+            
+        # Add TOC on page 2 with REAL page numbers (already calculated above)
+        try:
+            if toc_items:
+                add_table_of_contents_page(pdf, toc_items, request.businessIdea)
+            else:
+                # Add a basic TOC page if no items were generated
+                pdf.add_page()
+                pdf.set_font("Arial", "B", 20)
+                pdf.set_text_color(0, 0, 0)
+                pdf.set_xy(25, 25)
+                pdf.cell(0, 18, "Table of Contents", ln=True)
+                pdf.set_font("Arial", "", 12)
+                pdf.set_text_color(51, 51, 51)
+                pdf.set_xy(25, 50)
+                pdf.multi_cell(160, 8, "No sections available for table of contents.", align='L')
+        except Exception as e:
+            # logging.error(f"Table of contents failed: {str(e)}")
+            pass
+            # Add a basic TOC page as fallback
+            pdf.add_page()
+            pdf.set_font("Arial", "B", 20)
+            pdf.set_text_color(0, 0, 0)
+            pdf.set_xy(25, 25)
+            pdf.cell(0, 18, "Table of Contents", ln=True)
+            pdf.set_font("Arial", "", 12)
+            pdf.set_text_color(51, 51, 51)
+            pdf.set_xy(25, 50)
+            pdf.multi_cell(160, 8, "Table of contents could not be generated.", align='L')
+            
+        # Executive summary is now handled as part of the sections
+        # No separate page needed - the first section contains the executive summary
+            
+        try:
+            add_sections_with_charts()
+        except Exception as e:
+            raise Exception(f"Sections with charts failed: {str(e)}")
+            
+        # CRITICAL CHECK: Ensure we have content in the PDF
+        total_pages = pdf.page_no()
+        
+        if total_pages < 2:  # Should have at least cover + 1 content page
+            # Add a content page to prevent blank PDF
+            pdf.add_page()
+            pdf.set_font("Arial", "B", 16)
+            pdf.set_text_color(255, 0, 0)
+            pdf.cell(0, 20, "Content Processing Issue", ln=True, align='C')
+            pdf.set_font("Arial", "", 12)
+            pdf.set_text_color(0, 0, 0)
+            pdf.cell(0, 10, "The PDF generation encountered an issue with content processing.", ln=True, align='C')
+            pdf.cell(0, 10, "Please check the server logs for detailed information.", ln=True, align='C')
+        
+        # Get PDF output and convert to bytes
+        try:
+            pdf_output = pdf.output(dest='S')
+            if isinstance(pdf_output, bytearray):
+                pdf_bytes = bytes(pdf_output)
+            else:
+                pdf_bytes = pdf_output.encode('latin-1') if isinstance(pdf_output, str) else pdf_output
+            
+            # CRITICAL SAFETY CHECK: Ensure PDF is not empty
+            if len(pdf_bytes) < 1000:  # PDF should be at least 1KB
+                # Try to add some content to prevent blank PDF
+                pdf.add_page()
+                pdf.set_font("Arial", "B", 16)
+                pdf.set_text_color(255, 0, 0)  # Red text
+                pdf.cell(0, 20, "PDF Generation Issue Detected", ln=True, align='C')
+                pdf.set_font("Arial", "", 12)
+                pdf.set_text_color(0, 0, 0)
+                pdf.cell(0, 10, "If you see this message, there was an issue with content processing.", ln=True, align='C')
+                pdf.cell(0, 10, "Please check the server logs for details.", ln=True, align='C')
+                
+                # Regenerate PDF with error message
+                pdf_output = pdf.output(dest='S')
+                if isinstance(pdf_output, bytearray):
+                    pdf_bytes = bytes(pdf_output)
+                else:
+                    pdf_bytes = pdf_output.encode('latin-1') if isinstance(pdf_output, str) else pdf_output
+            
+            return pdf_bytes, f"business_plan_{request.businessIdea or 'export'}.pdf"
+        except Exception as e:
+            raise Exception(f"PDF conversion failed: {str(e)}")
+        
+    except Exception as e:
+        # logging.error(f"PDF generation failed: {e}")
+        raise Exception(f"Failed to generate professional PDF: {str(e)}")

app/DocumentGeneration/table_of_content.py

@@ -0,0 +1,205 @@
+# Table of Contents Module
+# Contains functions to generate TOC AFTER content is placed with real page numbers
+
+import re
+import os
+import sys
+from typing import List, Dict, Any
+
+# Add the parent directory to sys.path to import from models.py and constants.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportSection
+from constants import SECTION_ORDER
+
+def extract_first_heading_from_content(content: str) -> str:
+    """Extract the first heading from markdown content"""
+    if not content:
+        return ""
+    
+    lines = content.split('\n')
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        
+        # Check for markdown headings (# ## ### etc.)
+        if line.startswith('#'):
+            # Extract heading text without the # symbols
+            heading_text = re.sub(r'^#+\s*', '', line).strip()
+            if heading_text:
+                return heading_text
+        
+        # Check for bold headings (**text**)
+        elif line.startswith('**') and line.endswith('**') and len(line) > 4:
+            # Extract text from bold markers
+            heading_text = line[2:-2].strip()
+            if heading_text:
+                return heading_text
+    
+    return ""
+
+def generate_table_of_contents_after_content(sections: List[ExportSection], section_page_map: Dict[str, int], business_idea: str) -> List[Dict[str, Any]]:
+    """Generate TOC AFTER all content is placed, using REAL page numbers from section_page_map
+    This ensures accurate page numbers based on actual content placement"""
+    toc_items = []
+    
+    # Create a mapping from section titles to section objects for easy lookup
+    section_map = {section.title: section for section in sections}
+    
+    # Add business plan sections in the predefined SECTION_ORDER
+    for i, expected_title in enumerate(SECTION_ORDER):
+        # Find the corresponding section - try multiple matching strategies
+        section = None
+        
+        # Strategy 1: Exact title match
+        section = section_map.get(expected_title)
+        
+        # Strategy 2: Case-insensitive match
+        if not section:
+            for section_title, section_obj in section_map.items():
+                if section_title.lower() == expected_title.lower():
+                    section = section_obj
+                    break
+        
+        # Strategy 3: Partial match (e.g., "Company Profile" matches "Company Profile Section")
+        if not section:
+            for section_title, section_obj in section_map.items():
+                if (expected_title.lower() in section_title.lower() or 
+                    section_title.lower() in expected_title.lower()):
+                    section = section_obj
+                    break
+        
+        # Strategy 4: Key-based match (remove 'prompt_' prefix and match)
+        if not section:
+            for section_obj in sections:
+                if section_obj.key:
+                    key_clean = section_obj.key.replace('prompt_', '') if section_obj.key.startswith('prompt_') else section_obj.key
+                    if key_clean.lower() == expected_title.lower().replace(' ', '').replace('&', ''):
+                        section = section_obj
+                        break
+        
+        # Only add sections that have actual content AND real page numbers - NO DUMMY DATA
+        has_content = bool(section and section.content and section.content.strip())
+        if has_content:
+            # Get the REAL page number from section_page_map
+            real_page = section_page_map.get(section.title, 0)
+            if real_page > 0:  # Only add if we have a real page number
+                # Extract the actual heading from markdown content
+                actual_heading = extract_first_heading_from_content(section.content)
+                
+                # Use the actual heading from markdown content, fallback to expected title
+                toc_title = actual_heading if actual_heading else expected_title
+                
+                toc_items.append({
+                    "title": toc_title,  # Use actual heading from markdown content
+                    "level": 1,
+                    "page": real_page,  # REAL page number from actual content placement
+                    "section_type": "section",
+                    "has_content": True,
+                    "section_obj": section  # Store reference to actual section
+                })
+    
+    return toc_items
+
+def add_table_of_contents_page(pdf, toc_items: List[Dict[str, Any]], business_idea: str):
+    """Add a professional table of contents page with REAL page numbers"""
+    
+    # TOC items are already in the correct order and have real page numbers
+    sorted_toc_items = toc_items
+    
+    # Professional color scheme - Refined for bank/investor presentation
+    primary_color = (0, 0, 0)        # Black - for headings
+    accent_color = (75, 0, 130)      # Navy purple - for accent lines and highlights
+    text_color = (51, 51, 51)        # Dark gray - for body text
+    light_gray = (221, 221, 221)     # Lighter gray - for subtle lines (#DDDDDD)
+    navy_color = (25, 25, 112)       # Navy blue - for TOC and emphasis
+    
+    # Page title - more compact
+    pdf.set_font("Arial", "B", 20)  # Reduced from 24 to 20
+    pdf.set_text_color(*primary_color)
+    pdf.set_xy(25, 20)  # Reduced from 25 to 20
+    pdf.cell(0, 15, "Table of Contents", ln=True)  # Reduced from 18 to 15
+    
+    # Calculate text width and make line autofit
+    text_width = pdf.get_string_width("Table of Contents")
+    line_width = min(text_width + 12, 160)  # Add 12mm padding, max 160mm
+    
+    # Removed purple accent line under TOC title
+    
+    # TOC content - optimized for single page layout
+    y_position = 50  # Reduced from 60 to 50
+    pages_used = 1
+    
+    for item in sorted_toc_items:
+        # Only add new page if absolutely necessary (very close to bottom)
+        if y_position > 290:  # Very close to bottom margin
+            pdf.add_page()
+            y_position = 25
+            pages_used += 1
+        
+        # Indent based on level - better indentation
+        indent = 0 if item["level"] == 1 else 20  # Increased indent for subsections
+        
+        # Font and color based on level - ALL sections same color
+        if item["level"] == 1:
+            pdf.set_font("Arial", "B", 12)
+            pdf.set_text_color(*navy_color)  # Navy blue for all main entries
+        else:
+            pdf.set_font("Arial", "", 10)
+            pdf.set_text_color(*text_color)
+        
+        # Title with hyperlink
+        title_width = pdf.get_string_width(item["title"])
+        pdf.set_xy(25 + indent, y_position)
+        try:
+            # FPDF2 hyperlinks: test both 0-based and 1-based indexing
+            # First try 1-based (no subtraction)
+            target_page = item["page"]
+            # Try different FPDF2 link methods
+            if hasattr(pdf, 'add_link'):
+                link_id = pdf.add_link()
+                pdf.set_link(link_id, page=target_page)
+                pdf.link(25 + indent, y_position, title_width, 8, link_id)
+            else:
+                pdf.link(25 + indent, y_position, title_width, 8, dest=target_page)
+        except:
+            pass  # If hyperlink fails, continue without it
+        pdf.cell(title_width, 8, item["title"], ln=False)
+        
+        # Dots leading to page number
+        pdf.set_font("Arial", "", 8)
+        pdf.set_text_color(128, 128, 128)  # Medium gray for dots
+        
+        # Calculate dots position
+        title_width = pdf.get_string_width(item["title"])
+        dots_start = 25 + indent + title_width + 5
+        dots_end = 160
+        
+        # Draw dots
+        for x in range(int(dots_start), int(dots_end), 3):
+            pdf.set_xy(x, y_position + 3)
+            pdf.cell(1, 1, ".", ln=False)
+        
+        # Page number with hyperlink - NOW USING REAL PAGE NUMBERS
+        page_number_width = pdf.get_string_width(str(item["page"]))
+        pdf.set_xy(160, y_position)
+        try:
+            # FPDF2 hyperlinks: test both 0-based and 1-based indexing
+            # First try 1-based (no subtraction)
+            target_page = item["page"]
+            # Try different FPDF2 link methods
+            if hasattr(pdf, 'add_link'):
+                link_id = pdf.add_link()
+                pdf.set_link(link_id, page=target_page)
+                pdf.link(160, y_position, page_number_width, 8, link_id)
+            else:
+                pdf.link(160, y_position, page_number_width, 8, dest=target_page)
+        except:
+            pass  # If hyperlink fails, continue without it
+        pdf.cell(0, 8, str(item["page"]), ln=False)
+        
+        # Reduced spacing between items for better page utilization
+        y_position += 8  # Reduced from 10 to 8 for even tighter spacing
+    
+    # Add some spacing at the end
+    pdf.ln(20)

app/DocumentGeneration/word_generator.py

@@ -0,0 +1,279 @@
+# Word Generator Module
+# Contains create_word_document() and all Word-related functions
+
+import re
+import os
+import tempfile
+import time
+import io
+import sys
+from typing import List, Dict, Any
+
+# Add the parent directory to sys.path to import from models.py
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+from models import ExportRequest
+
+# Import from the same directory (Document Generation)
+from document_helpers import (
+    filter_empty_sections,
+    extract_business_name_from_content
+)
+# from table_of_content import generate_table_of_contents  # Not used in word generator
+from chart_generator import parse_embedded_chart_data, create_chart_from_data
+from markdown_renderer import (
+    render_markdown_to_docx_grouped,
+    process_content_with_inline_charts
+)
+
+# Add Currency Mapping path
+sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'Currency Mapping'))
+from CurrencyMapping.currency_mapping import convert_currency_symbols_to_iso
+
+def create_word_document(request: ExportRequest):
+    """Create a Word document from the business plan data with front page, TOC, and proper page breaks"""
+    try:
+        from docx import Document
+        from docx.shared import Inches, Pt, RGBColor
+        from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_TAB_ALIGNMENT
+        from docx.oxml import OxmlElement
+        from docx.oxml.ns import qn
+    except ImportError:
+        raise Exception("python-docx is not installed. Please install it with: pip install python-docx")
+    
+    # Filter out empty sections to prevent blank pages
+    try:
+        filtered_sections = filter_empty_sections(request.sections)
+    except Exception as e:
+        raise Exception(f"Failed to filter sections: {str(e)}")
+    if not filtered_sections:
+        raise Exception("No valid sections found after filtering. All sections appear to be empty.")
+    
+    doc = Document()
+    
+    # Add confidentiality footer to every page
+    section = doc.sections[0]
+    footer = section.footer
+    footer_para = footer.paragraphs[0]
+    footer_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    footer_run = footer_para.add_run("CONFIDENTIAL - This document contains proprietary information and may not be shared without consent")
+    footer_run.font.size = Pt(8)
+    footer_run.font.color.rgb = RGBColor(100, 100, 100)  # Gray text
+    
+    # ===== FRONT PAGE =====
+    # Add company logo at the top
+    try:
+        # Use the MBD logo PNG file
+        project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+        logo_path = os.path.join(project_root, 'assets', 'logos', 'MBD logo.png')
+        
+        if os.path.exists(logo_path):
+            # Add logo to Word document (centered, top of page)
+            logo_para = doc.add_paragraph()
+            logo_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            logo_run = logo_para.add_run()
+            logo_run.add_picture(logo_path, width=Inches(3.0))  # Even larger size to show full logo
+            print(f"Logo added successfully from: {logo_path}")
+        else:
+            print(f"Logo file not found at: {logo_path}")
+    except Exception as e:
+        # Log any errors with logo
+        print(f"Logo error: {e}")
+        pass
+    
+    # Add top spacing
+    doc.add_paragraph()
+    doc.add_paragraph()
+    
+    # Extract business name from content, fallback to businessIdea
+    extracted_business_name = extract_business_name_from_content(filtered_sections)
+    business_name = extracted_business_name or request.businessIdea or "Business Plan"
+    
+    # Business name as main title with enhanced styling - PURPLE THEME
+    title = doc.add_heading(business_name, 0)
+    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    
+    # Style the title with larger font and PURPLE color
+    for run in title.runs:
+        run.font.size = Pt(36)
+        run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
+    
+    # Removed decorative line under title
+    
+    # Add subtitle with enhanced styling - PURPLE
+    doc.add_paragraph()
+    subtitle = doc.add_paragraph("Professional Business Plan Document")
+    subtitle.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    subtitle_run = subtitle.runs[0]
+    subtitle_run.font.size = Pt(18)
+    subtitle_run.font.color.rgb = RGBColor(124, 58, 237)  # DARKER PURPLE
+    subtitle_run.italic = True
+    
+    # Add more spacing
+    doc.add_paragraph()
+    doc.add_paragraph()
+    doc.add_paragraph()
+    
+    # Add document info in a styled box - PURPLE BORDER
+    info_para = doc.add_paragraph()
+    info_para.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    
+    # Add background color and border styling
+    info_run = info_para.add_run("Prepared by: Business Plan Generator")
+    info_run.font.size = Pt(14)
+    info_run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
+    
+    doc.add_paragraph()
+    date_para = doc.add_paragraph()
+    date_para.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    date_run = date_para.add_run(f"Date: {time.strftime('%B %Y')}")
+    date_run.font.size = Pt(14)
+    date_run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
+    
+    # Confidentiality statement removed - now in footer of every page
+    
+    # Add more spacing before footer
+    doc.add_paragraph()
+    doc.add_paragraph()
+    doc.add_paragraph()
+    doc.add_paragraph()
+    
+    # Add footer with enhanced styling - PURPLE
+    footer = doc.add_paragraph("Confidential Business Information")
+    footer.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    footer_run = footer.runs[0]
+    footer_run.font.size = Pt(12)
+    footer_run.font.color.rgb = RGBColor(139, 92, 246)  # PURPLE
+    footer_run.bold = True
+    
+    # Removed decorative line above footer
+    
+    # ===== TABLE OF CONTENTS =====
+    # Add page break before TOC
+    doc.add_page_break()
+    
+    # Add TOC title
+    toc_title = doc.add_heading("Table of Contents", level=1)
+    toc_title.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    
+    # Removed decorative line under TOC title
+    
+    # Add spacing before TOC entries
+    doc.add_paragraph()
+    
+    # Sort sections according to predefined order (do this before TOC generation)
+    try:
+        sorted_sections = sort_sections_by_order(filtered_sections)
+    except Exception as e:
+        # Fallback: use filtered order if sorting fails
+        sorted_sections = filtered_sections
+    
+    # Generate TOC entries with actual page numbers
+    # Since each section starts on a new page, we can calculate page numbers
+    toc_items = []
+    current_page = 3  # Start after cover (1) and TOC (2)
+    
+    for section in sorted_sections:
+        if section.content and section.content.strip():
+            # Add main section
+            toc_items.append({
+                "title": section.title,
+                "level": 1,
+                "page": current_page
+            })
+            
+            # Skip subheadings and chart titles - only include main section headings
+            
+            current_page += 1  # Each section starts on a new page
+    
+    # Add the actual TOC entries
+    for item in toc_items:
+        # Create TOC entry paragraph
+        toc_para = doc.add_paragraph()
+        toc_para.paragraph_format.space_after = Pt(6)
+        
+        # Add section title
+        title_run = toc_para.add_run(item["title"])
+        title_run.font.size = Pt(11)
+        
+        # Add dots and page number
+        if item["level"] == 1:
+            # Main section - bold
+            title_run.bold = True
+            # Add dots
+            dots_run = toc_para.add_run(" " + "." * (60 - len(item["title"])) + " ")
+            dots_run.font.size = Pt(11)
+            dots_run.font.color.rgb = RGBColor(128, 128, 128)  # Gray
+            # Add page number
+            page_run = toc_para.add_run(str(item["page"]))
+            page_run.font.size = Pt(11)
+            page_run.bold = True
+        else:
+            # Subsection - indented
+            toc_para.paragraph_format.left_indent = Inches(0.3)
+            # Add dots
+            dots_run = toc_para.add_run(" " + "." * (50 - len(item["title"])) + " ")
+            dots_run.font.size = Pt(11)
+            dots_run.font.color.rgb = RGBColor(128, 128, 128)  # Gray
+            # Add page number
+            page_run = toc_para.add_run(str(item["page"]))
+            page_run.font.size = Pt(11)
+    
+    # logging.info(f"Generated {len(toc_items)} TOC items with actual page numbers")
+    
+    # Executive Summary is now handled as a regular section above
+    
+    # ===== MAIN SECTIONS =====
+    for i, section in enumerate(sorted_sections):
+        if section.content.strip():
+            # Add page break before each section (including Executive Summary)
+            doc.add_page_break()
+            
+            # Add section heading
+            doc.add_heading(section.title, level=1)
+            
+            # Clean and process content WITH inline charts
+            try:
+                clean_content = clean_text_for_pdf(section.content)
+            except Exception:
+                clean_content = section.content or ""
+            try:
+                clean_content = convert_currency_symbols_to_iso(clean_content)
+            except Exception:
+                pass
+            
+            # Remove the section title from content to prevent duplication
+            section_title_clean = section.title.strip()
+            content_lines = clean_content.split('\n')
+            filtered_lines = []
+            for line in content_lines:
+                line_clean = line.strip()
+                # Skip lines that match the section title (with or without markdown)
+                # Check for various markdown formats and variations
+                if (line_clean == section_title_clean or 
+                    line_clean == f"**{section_title_clean}**" or
+                    line_clean == f"# {section_title_clean}" or
+                    line_clean == f"## {section_title_clean}" or
+                    line_clean == f"### {section_title_clean}" or
+                    line_clean == f"#### {section_title_clean}" or
+                    # Also check if the line starts with the section title (for numbered headings)
+                    line_clean.startswith(f"{section_title_clean}") and len(line_clean) <= len(section_title_clean) + 10):
+                    continue
+                filtered_lines.append(line)
+            clean_content = '\n'.join(filtered_lines)
+            
+            # Process content with inline charts - THIS IS THE KEY CHANGE
+            process_content_with_inline_charts(doc, clean_content, request.businessIdea or "Business")
+            
+            doc.add_paragraph()
+    
+    # Charts are now handled inline with the sections above
+    
+    # Save to bytes
+    buffer = io.BytesIO()
+    doc.save(buffer)
+    buffer.seek(0)
+    doc_bytes = buffer.getvalue()
+    buffer.close()
+    
+    filename = f"business_plan_{request.businessIdea or 'export'}.docx"
+    return doc_bytes, filename

app/__init__.py

@@ -0,0 +1,29 @@
+# App Package
+# This file makes the app directory a proper Python package
+
+import os
+import sys
+
+# Add the current directory to sys.path
+current_dir = os.path.dirname(__file__)
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+# Import main modules for easy access
+from models import ExportRequest, ExportSection, ExportResponse, SectionJob, BatchGenerateRequest, GenerateRequest, CreatePlanRequest
+from constants import SECTION_ORDER, SECTION_MAP, SECTION_COLUMNS
+from utils import sort_sections_by_order
+
+__all__ = [
+    'ExportRequest',
+    'ExportSection', 
+    'ExportResponse',
+    'SectionJob',
+    'BatchGenerateRequest',
+    'GenerateRequest',
+    'CreatePlanRequest',
+    'SECTION_ORDER',
+    'SECTION_MAP',
+    'SECTION_COLUMNS',
+    'sort_sections_by_order'
+]

app/constants.py

@@ -0,0 +1,41 @@
+# Constants and Configuration
+# Contains constants and configuration values to avoid circular imports
+
+# Human-readable section titles for TOC and display
+SECTION_ORDER = [
+    "Executive Summary",
+    "Company Profile", 
+    "Market Analysis",
+    "Product or Service",
+    "Business Model",
+    "Marketing & Growth",
+    "Operations Plan",
+    "Management Team",
+    "Financial Plan & Funding"
+]
+
+# Database helper constants
+SECTION_MAP = {
+    "prompt_ExecutiveSummary": ("executiveSummary", "executiveSummaryComplete", "executiveSummaryGenerating"),
+    "prompt_CompanyProfile": ("companyProfile", "companyProfileComplete", "companyProfileGenerating"),
+    "prompt_MarketAnalysis": ("marketAnalysis", "marketAnalysisComplete", "marketAnalysisGenerating"),
+    "prompt_ProductOrService": ("productOrService", "productOrServiceComplete", "productOrServiceGenerating"),
+    "prompt_BusinessModel": ("businessModel", "businessModelComplete", "businessModelGenerating"),
+    "prompt_MarketingGrowth": ("marketingGrowth", "marketingGrowthComplete", "marketingGrowthGenerating"),
+    "prompt_OperationsPlan": ("operationsPlan", "operationsPlanComplete", "operationsPlanGenerating"),
+    "prompt_ManagementTeam": ("managementTeam", "managementTeamComplete", "managementTeamGenerating"),
+    "prompt_FinancialPlanFunding": ("financialPlanFunding", "financialPlanFundingComplete", "financialPlanFundingGenerating"),
+}
+
+# Database column names for sections
+SECTION_COLUMNS = [
+    "executiveSummary",
+    "companyProfile",
+    "marketAnalysis",
+    "productOrService",
+    "businessModel",
+    "marketingGrowth",
+    "operationsPlan",
+    "managementTeam",
+    "financialPlanFunding",
+]

app/models.py

@@ -0,0 +1,61 @@
+# Models and Data Structures
+# Contains Pydantic models and data structures to avoid circular imports
+
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional, Literal
+
+class ExportSection(BaseModel):
+    """Represents a section of content for export"""
+    title: str
+    content: str
+    key: Optional[str] = None
+    order: Optional[int] = None
+
+class ExportRequest(BaseModel):
+    """Request model for document export"""
+    sections: List[ExportSection]
+    businessIdea: str
+    summary: str
+    format: Literal["pdf", "word"] = "pdf"
+    chartImages: Optional[List[str]] = None
+    includeCharts: bool = True
+    includeTOC: bool = True
+
+class ExportResponse(BaseModel):
+    """Response model for document export"""
+    success: bool
+    message: str
+    filename: Optional[str] = None
+    size: Optional[int] = None
+    downloadUrl: Optional[str] = None
+    documentData: Optional[str] = None
+
+class SectionJob(BaseModel):
+    """Job model for section generation"""
+    businessPlanId: str
+    sectionKey: str
+    businessIdea: str
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None
+
+class BatchGenerateRequest(BaseModel):
+    """Request model for batch generation"""
+    businessPlanId: str
+    businessIdea: str
+    sections: List[str]
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None
+
+class GenerateRequest(BaseModel):
+    """Request model for single section generation"""
+    businessPlanId: str
+    sectionKey: str
+    businessIdea: str
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None
+
+class CreatePlanRequest(BaseModel):
+    """Request model for creating a new business plan"""
+    businessIdea: str
+    countryCode: Optional[str] = None
+    defaultCountry: Optional[str] = None

app/utils.py

@@ -0,0 +1,42 @@
+# Utility functions shared across modules
+# This file helps break circular imports between main.py and pdf_generator.py
+
+from typing import List
+from models import ExportSection
+from constants import SECTION_ORDER
+
+def sort_sections_by_order(sections: List[ExportSection]) -> List[ExportSection]:
+    """Sort sections according to the predefined SECTION_ORDER to ensure correct numerical ordering"""
+    # Create a mapping from section title to order index
+    order_map = {title: index for index, title in enumerate(SECTION_ORDER)}
+    
+    def get_section_order(section: ExportSection) -> int:
+        # Try to match by exact title first
+        if section.title in order_map:
+            order_index = order_map[section.title]
+            return order_index
+        
+        # Try case-insensitive matching
+        section_title_lower = section.title.lower()
+        for order_title, order_index in order_map.items():
+            if order_title.lower() == section_title_lower:
+                return order_index
+        
+        # Try to match by key (remove 'prompt_' prefix if present)
+        key_clean = section.key.replace('prompt_', '') if section.key.startswith('prompt_') else section.key
+        if key_clean in order_map:
+            order_index = order_map[key_clean]
+            return order_index
+        
+        # Try partial matching for keys
+        for order_title, order_index in order_map.items():
+            if key_clean.lower() in order_title.lower() or order_title.lower() in key_clean.lower():
+                return order_index
+        
+        # If no match found, put at the end
+        return len(SECTION_ORDER)
+    
+    # Sort sections by their order
+    sorted_sections = sorted(sections, key=get_section_order)
+    
+    return sorted_sections

package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "planify",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}