common Schema Comparison Report (QA vs TEST)

-- SOURCE
CREATE OR REPLACE FUNCTION public.get_income_expense_overview(p_company_id uuid, p_period_type integer, p_finance_id integer)
 RETURNS TABLE(period text, year numeric, total_income numeric, total_expense numeric, actual_income numeric, actual_expense numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_finance_year_start NUMERIC;
    v_finance_year_end NUMERIC;

    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
    CONST_YTD CONSTANT INTEGER := 5;
BEGIN
    IF p_period_type != CONST_YTD THEN
        SELECT start_date, end_date,
               EXTRACT(YEAR FROM start_date),
               EXTRACT(YEAR FROM end_date)
        INTO v_financial_year_start, v_financial_year_end,
             v_finance_year_start, v_finance_year_end
        FROM public.finance_year
        WHERE id = p_finance_id;
    END IF;

    IF p_period_type = CONST_YTD THEN
        -- Returns last 5 years, fiscal quarters (Apr–Jun, Jul–Sep, Oct–Dec, Jan–Mar)
       RETURN QUERY
    WITH recent_years AS (
        SELECT fy.id, fy.start_date, fy.end_date,
               EXTRACT(YEAR FROM fy.start_date) AS fiscal_year
        FROM public.finance_year fy
        WHERE EXTRACT(YEAR FROM fy.start_date) >= EXTRACT(YEAR FROM CURRENT_DATE) - 4
          AND EXTRACT(YEAR FROM fy.start_date) <= EXTRACT(YEAR FROM CURRENT_DATE)
        ORDER BY fy.start_date DESC
        LIMIT 5
    ),
    quarters AS (
        SELECT id AS finance_id, fiscal_year, 'Q1' AS period,
               make_date(fiscal_year::int, 4, 1) AS period_start,
               make_date(fiscal_year::int, 6, 30) AS period_end
          FROM recent_years
        UNION ALL
        SELECT id, fiscal_year, 'Q2',
               make_date(fiscal_year::int, 7, 1),
               make_date(fiscal_year::int, 9, 30)
          FROM recent_years
        UNION ALL
        SELECT id, fiscal_year, 'Q3',
               make_date(fiscal_year::int, 10, 1),
               make_date(fiscal_year::int, 12, 31)
          FROM recent_years
        UNION ALL
        -- For Q4, fiscal_year stays the same, but period_start/period_end move to the next calendar year
        SELECT id, fiscal_year, 'Q4',
               make_date((fiscal_year::int) + 1, 1, 1),
               make_date((fiscal_year::int) + 1, 3, 31)
          FROM recent_years
    ),
    filtered_je AS (
        SELECT
            je.amount,
            je.entry_type,
            tr.company_id,
            je.transaction_date,
            coa.account_type_id
        FROM journal_entries je
        JOIN transaction_headers tr ON je.transaction_id = tr.id
        JOIN chart_of_accounts coa ON je.account_id = coa.id
        WHERE je.is_deleted = FALSE
          AND tr.company_id = p_company_id
    )
    SELECT
        CONCAT(q.period, ' ', q.fiscal_year) AS period,
        q.fiscal_year,
        COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS total_income,
        COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,
        COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,
        COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense
    FROM quarters q
    LEFT JOIN filtered_je je
        ON je.transaction_date BETWEEN q.period_start AND q.period_end
    GROUP BY q.period, q.fiscal_year
    HAVING
        SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
     OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
     OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
     OR SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
    ORDER BY q.fiscal_year, q.period;

    ELSIF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        WITH months AS (
            SELECT
                generate_series::date AS month_start,
                (generate_series + interval '1 month')::date AS month_end
            FROM generate_series(
                v_financial_year_start,
                v_financial_year_end,
                interval '1 month'
            )
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            to_char(m.month_start, 'Mon YYYY') AS period,
            EXTRACT(YEAR FROM m.month_start) AS year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM months m
        LEFT JOIN filtered_je je
            ON je.transaction_date >= m.month_start AND je.transaction_date < m.month_end
        GROUP BY m.month_start
        ORDER BY m.month_start;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        -- Single year, use explicit fiscal quarters
        RETURN QUERY
        WITH fiscal_quarters AS (
            SELECT 'Q1' AS period, v_financial_year_start AS period_start, make_date(v_finance_year_start::int, 6, 30) AS period_end, v_finance_year_start AS year
            UNION ALL
            SELECT 'Q2', make_date(v_finance_year_start::int, 7, 1), make_date(v_finance_year_start::int, 9, 30), v_finance_year_start
            UNION ALL
            SELECT 'Q3', make_date(v_finance_year_start::int, 10, 1), make_date(v_finance_year_start::int, 12, 31), v_finance_year_start
            UNION ALL
            SELECT 'Q4', make_date((v_finance_year_start::int) + 1, 1, 1), v_financial_year_end, v_finance_year_start
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(fq.period, ' ', fq.year) AS period,
            fq.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM fiscal_quarters fq
        LEFT JOIN filtered_je je
            ON je.transaction_date BETWEEN fq.period_start AND fq.period_end
        GROUP BY fq.period, fq.year
        ORDER BY fq.year, fq.period;

    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        WITH half_years AS (
            SELECT 'H1' AS period, v_financial_year_start AS period_start, make_date(v_finance_year_start::int, 9, 30) AS period_end, v_finance_year_start AS year
            UNION ALL
            SELECT 'H2', make_date(v_finance_year_start::int, 10, 1), v_financial_year_end, v_finance_year_start
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(h.period, ' ', h.year) AS period,
            h.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM half_years h
        JOIN filtered_je je
            ON je.transaction_date BETWEEN h.period_start AND h.period_end
        GROUP BY h.period, h.year
        ORDER BY h.year, h.period;

    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        WITH filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT('Year ', v_finance_year_start) AS period,
            v_finance_year_start AS year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM filtered_je je;

    ELSE
        RAISE EXCEPTION 'Unsupported period type %', p_period_type;
    END IF;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_income_expense_overview(p_company_id uuid, p_period_type integer, p_finance_id integer)
 RETURNS TABLE(period text, year numeric, total_income numeric, total_expense numeric, actual_income numeric, actual_expense numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_financial_year_start date;
    v_financial_year_end date;
    v_finance_year_start numeric;
    v_finance_year_end numeric;

    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
    CONST_YTD CONSTANT INTEGER := 5;
BEGIN
    IF p_period_type != CONST_YTD THEN
        SELECT start_date, end_date,
               EXTRACT(YEAR FROM start_date),
               EXTRACT(YEAR FROM end_date)
        INTO v_financial_year_start, v_financial_year_end,
             v_finance_year_start, v_finance_year_end
        FROM public.finance_year
        WHERE id = p_finance_id;
    END IF;

    IF p_period_type = CONST_YTD THEN
        RETURN QUERY
        WITH recent_years AS (
            SELECT fy.id, fy.start_date, fy.end_date,
                   EXTRACT(YEAR FROM fy.start_date) AS year_start,
                   EXTRACT(YEAR FROM fy.end_date) AS year_end
            FROM finance_year fy
            WHERE EXTRACT(YEAR FROM fy.start_date) >= EXTRACT(YEAR FROM CURRENT_DATE) - 4
              AND EXTRACT(YEAR FROM fy.start_date) <= EXTRACT(YEAR FROM CURRENT_DATE)
            ORDER BY fy.start_date DESC
            LIMIT 5
        ),
        ytd_periods AS (
            SELECT id AS finance_id, 'YTD H1' AS period,
                   (start_date + INTERVAL '5 months 29 days')::date AS period_end,
                   EXTRACT(YEAR FROM start_date) AS year,
                   start_date AS fy_start
            FROM recent_years
            UNION ALL
            SELECT id, 'YTD H2', end_date,
                   EXTRACT(YEAR FROM end_date) AS year,
                   start_date
            FROM recent_years
            WHERE end_date <= CURRENT_DATE
              AND CURRENT_DATE >= (start_date + INTERVAL '6 months') -- skip if it's a future YTD H2
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                tr.company_id,
                tr.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE je.is_deleted = FALSE
        )
        SELECT
            CONCAT(yp.period, ' ', yp.year) AS period,
            yp.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0)
        FROM ytd_periods yp
        LEFT JOIN filtered_je je ON je.company_id = p_company_id
        GROUP BY yp.period, yp.year, yp.period_end
        HAVING
            SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
         OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
         OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
         OR SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
        ORDER BY yp.year, yp.period;

    ELSIF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        WITH months AS (
            SELECT
                generate_series::date AS month_start,
                (generate_series + interval '1 month')::date AS month_end
            FROM generate_series(
                v_financial_year_start,
                v_financial_year_end,
                interval '1 month'
            )
        ),
        filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            to_char(m.month_start, 'Mon YYYY') AS period,
            EXTRACT(YEAR FROM m.month_start) AS year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM months m
        LEFT JOIN filtered_je je ON je.transaction_date >= m.month_start AND je.transaction_date < m.month_end
        GROUP BY m.month_start
        ORDER BY m.month_start;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        RETURN QUERY
        WITH quarters AS (
            SELECT 'Q1' AS period, 4 AS start_month, 6 AS end_month, v_finance_year_start AS year
            UNION ALL SELECT 'Q2', 7, 9, v_finance_year_start
            UNION ALL SELECT 'Q3', 10, 12, v_finance_year_start
            UNION ALL SELECT 'Q4', 1, 3, v_finance_year_end
        ),
        filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(q.period, ' ', q.year),
            q.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM quarters q
        JOIN filtered_je je ON EXTRACT(MONTH FROM je.transaction_date) BETWEEN q.start_month AND q.end_month
                             AND EXTRACT(YEAR FROM je.transaction_date) = q.year
        GROUP BY q.period, q.year
        ORDER BY q.year, q.period;

    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        WITH half_years AS (
            SELECT 'H1' AS period, 4 AS start_month, 9 AS end_month, v_finance_year_start AS year
            UNION ALL SELECT 'H2', 10, 12, v_finance_year_start
            UNION ALL SELECT 'H2', 1, 3, v_finance_year_end
        ),
        filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(h.period, ' ', h.year),
            h.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM half_years h
        JOIN filtered_je je ON EXTRACT(MONTH FROM je.transaction_date) BETWEEN h.start_month AND h.end_month
                             AND EXTRACT(YEAR FROM je.transaction_date) = h.year
        GROUP BY h.period, h.year
        ORDER BY h.year, h.period;

    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        WITH filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT('Year ', EXTRACT(YEAR FROM je.transaction_date)),
            EXTRACT(YEAR FROM je.transaction_date),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM filtered_je je
        GROUP BY EXTRACT(YEAR FROM je.transaction_date)
        ORDER BY EXTRACT(YEAR FROM je.transaction_date);

    ELSE
        RAISE EXCEPTION 'Unsupported period type %', p_period_type;
    END IF;
END;
$function$

Source Script

Target Script

CREATE OR REPLACE FUNCTION public.get_income_expense_overview(p_company_id uuid, p_period_type integer, p_finance_id integer)

CREATE OR REPLACE FUNCTION public.get_income_expense_overview(p_company_id uuid, p_period_type integer, p_finance_id integer)

 RETURNS TABLE(period text, year numeric, total_income numeric, total_expense numeric, actual_income numeric, actual_expense numeric)

 RETURNS TABLE(period text, year numeric, total_income numeric, total_expense numeric, actual_income numeric, actual_expense numeric)

3 LANGUAGE plpgsql

4 AS $function$

5 DECLARE

6 v_financial_year_start DATE;

6 v_financial_year_start date;

7 v_financial_year_end DATE;

7 v_financial_year_end date;

8 v_finance_year_start NUMERIC;

8 v_finance_year_start numeric;

9 v_finance_year_end NUMERIC;

9 v_finance_year_end numeric;

11 CONST_MONTHLY CONSTANT INTEGER := 1;

12 CONST_QUARTERLY CONSTANT INTEGER := 2;

13 CONST_HALF_YEARLY CONSTANT INTEGER := 3;

14 CONST_YEARLY CONSTANT INTEGER := 4;

15 CONST_YTD CONSTANT INTEGER := 5;

16 BEGIN

17 IF p_period_type != CONST_YTD THEN

18 SELECT start_date, end_date,

19 EXTRACT(YEAR FROM start_date),

20 EXTRACT(YEAR FROM end_date)

21 INTO v_financial_year_start, v_financial_year_end,

22 v_finance_year_start, v_finance_year_end

23 FROM public.finance_year

24 WHERE id = p_finance_id;

25 END IF;

27 IF p_period_type = CONST_YTD THEN

28 -- Returns last 5 years, fiscal quarters (Apr–Jun, Jul–Sep, Oct–Dec, Jan–Mar)

29 RETURN QUERY

28 RETURN QUERY

30 WITH recent_years AS (

29 WITH recent_years AS (

31 SELECT fy.id, fy.start_date, fy.end_date,

30 SELECT fy.id, fy.start_date, fy.end_date,

32 EXTRACT(YEAR FROM fy.start_date) AS fiscal_year

31 EXTRACT(YEAR FROM fy.start_date) AS year_start,

33 FROM public.finance_year fy

32 EXTRACT(YEAR FROM fy.end_date) AS year_end

33 FROM finance_year fy

34 WHERE EXTRACT(YEAR FROM fy.start_date) >= EXTRACT(YEAR FROM CURRENT_DATE) - 4

35 AND EXTRACT(YEAR FROM fy.start_date) <= EXTRACT(YEAR FROM CURRENT_DATE)

36 ORDER BY fy.start_date DESC

37 LIMIT 5

38 ),

39 quarters AS (

39 ytd_periods AS (

40 SELECT id AS finance_id, fiscal_year, 'Q1' AS period,

40 SELECT id AS finance_id, 'YTD H1' AS period,

41 make_date(fiscal_year::int, 4, 1) AS period_start,

41 (start_date + INTERVAL '5 months 29 days')::date AS period_end,

42 make_date(fiscal_year::int, 6, 30) AS period_end

42 EXTRACT(YEAR FROM start_date) AS year,

43 FROM recent_years

43 start_date AS fy_start

44 UNION ALL

45 SELECT id, fiscal_year, 'Q2',

46 make_date(fiscal_year::int, 7, 1),

47 make_date(fiscal_year::int, 9, 30)

48 FROM recent_years

44 FROM recent_years

49 UNION ALL

45 UNION ALL

50 SELECT id, fiscal_year, 'Q3',

46 SELECT id, 'YTD H2', end_date,

51 make_date(fiscal_year::int, 10, 1),

47 EXTRACT(YEAR FROM end_date) AS year,

52 make_date(fiscal_year::int, 12, 31)

48 start_date

53 FROM recent_years

49 FROM recent_years

54 UNION ALL

50 WHERE end_date <= CURRENT_DATE

55 -- For Q4, fiscal_year stays the same, but period_start/period_end move to the next calendar year

51 AND CURRENT_DATE >= (start_date + INTERVAL '6 months') -- skip if it's a future YTD H2

56 SELECT id, fiscal_year, 'Q4',

57 make_date((fiscal_year::int) + 1, 1, 1),

58 make_date((fiscal_year::int) + 1, 3, 31)

59 FROM recent_years

60 ),

52 ),

61 filtered_je AS (

53 filtered_je AS (

62 SELECT

54 SELECT

63 je.amount,

55 je.amount,

64 je.entry_type,

56 je.entry_type,

65 tr.company_id,

57 tr.company_id,

66 je.transaction_date,

58 tr.transaction_date,

67 coa.account_type_id

59 coa.account_type_id

68 FROM journal_entries je

60 FROM journal_entries je

69 JOIN transaction_headers tr ON je.transaction_id = tr.id

61 JOIN transaction_headers tr ON je.transaction_id = tr.id

70 JOIN chart_of_accounts coa ON je.account_id = coa.id

62 JOIN chart_of_accounts coa ON je.account_id = coa.id

71 WHERE je.is_deleted = FALSE

63 WHERE je.is_deleted = FALSE

72 AND tr.company_id = p_company_id

73 )

64 )

74 SELECT

65 SELECT

75 CONCAT(q.period, ' ', q.fiscal_year) AS period,

66 CONCAT(yp.period, ' ', yp.year) AS period,

76 q.fiscal_year,

67 yp.year,

77 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)

68 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)

                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS total_income,

                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),

79 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)

70 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)

                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,

                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),

81 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)

72 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)

                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,

                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),

83 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)

74 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)

                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense

                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0)

85 FROM quarters q

76 FROM ytd_periods yp

86 LEFT JOIN filtered_je je

77 LEFT JOIN filtered_je je ON je.company_id = p_company_id

87 ON je.transaction_date BETWEEN q.period_start AND q.period_end

78 GROUP BY yp.period, yp.year, yp.period_end

88 GROUP BY q.period, q.fiscal_year

89 HAVING

79 HAVING

90 SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)

80 SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)

91 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0

81 AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0

92 OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)

82 OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)

93 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0

83 AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0

94 OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)

84 OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)

95 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0

85 AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0

96 OR SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)

86 OR SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)

97 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0

87 AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0

98 ORDER BY q.fiscal_year, q.period;

88 ORDER BY yp.year, yp.period;

100 ELSIF p_period_type = CONST_MONTHLY THEN

90 ELSIF p_period_type = CONST_MONTHLY THEN

101 RETURN QUERY

91 RETURN QUERY

102 WITH months AS (

92 WITH months AS (

103 SELECT

93 SELECT

104 generate_series::date AS month_start,

94 generate_series::date AS month_start,

105 (generate_series + interval '1 month')::date AS month_end

95 (generate_series + interval '1 month')::date AS month_end

106 FROM generate_series(

96 FROM generate_series(

107 v_financial_year_start,

97 v_financial_year_start,

108 v_financial_year_end,

98 v_financial_year_end,

109 interval '1 month'

99 interval '1 month'

110 )

100 )

111 ),

101 ),

112 filtered_je AS (

102 filtered_je AS (

113 SELECT

103 SELECT

114 je.amount,

104 je.*,

115 je.entry_type,

116 je.transaction_date,

117 coa.account_type_id

105 coa.account_type_id

118 FROM journal_entries je

106 FROM journal_entries je

119 JOIN transaction_headers tr ON je.transaction_id = tr.id

107 JOIN transaction_headers tr ON je.transaction_id = tr.id

120 JOIN chart_of_accounts coa ON je.account_id = coa.id

108 JOIN chart_of_accounts coa ON je.account_id = coa.id

121 WHERE tr.company_id = p_company_id

109 WHERE tr.company_id = p_company_id

122 AND je.is_deleted = FALSE

110 AND je.is_deleted = FALSE

123 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

111 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

124 )

112 )

125 SELECT

113 SELECT

126 to_char(m.month_start, 'Mon YYYY') AS period,

114 to_char(m.month_start, 'Mon YYYY') AS period,

127 EXTRACT(YEAR FROM m.month_start) AS year,

115 EXTRACT(YEAR FROM m.month_start) AS year,

128 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)

116

            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),

129

                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS total_income,

117

            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),

130 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)

118 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),

131

                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS total_expense,

119 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)

132 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)

133

                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS actual_income,

134 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)

135

                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS actual_expense

136 FROM months m

120 FROM months m

137 LEFT JOIN filtered_je je

121 LEFT JOIN filtered_je je ON je.transaction_date >= m.month_start AND je.transaction_date < m.month_end

138 ON je.transaction_date >= m.month_start AND je.transaction_date < m.month_end

139 GROUP BY m.month_start

122 GROUP BY m.month_start

140 ORDER BY m.month_start;

123 ORDER BY m.month_start;

141

124

142 ELSIF p_period_type = CONST_QUARTERLY THEN

125 ELSIF p_period_type = CONST_QUARTERLY THEN

143 -- Single year, use explicit fiscal quarters

144 RETURN QUERY

126 RETURN QUERY

145 WITH fiscal_quarters AS (

127 WITH quarters AS (

146

            SELECT 'Q1' AS period, v_financial_year_start AS period_start, make_date(v_finance_year_start::int, 6, 30) AS period_end, v_finance_year_start AS year

128 SELECT 'Q1' AS period, 4 AS start_month, 6 AS end_month, v_finance_year_start AS year

147 UNION ALL

129 UNION ALL SELECT 'Q2', 7, 9, v_finance_year_start

148

            SELECT 'Q2', make_date(v_finance_year_start::int, 7, 1), make_date(v_finance_year_start::int, 9, 30), v_finance_year_start

130 UNION ALL SELECT 'Q3', 10, 12, v_finance_year_start

149 UNION ALL

131 UNION ALL SELECT 'Q4', 1, 3, v_finance_year_end

150

            SELECT 'Q3', make_date(v_finance_year_start::int, 10, 1), make_date(v_finance_year_start::int, 12, 31), v_finance_year_start

151 UNION ALL

152 SELECT 'Q4', make_date((v_finance_year_start::int) + 1, 1, 1), v_financial_year_end, v_finance_year_start

153 ),

132 ),

154 filtered_je AS (

133 filtered_je AS (

155 SELECT

134 SELECT

156 je.amount,

135 je.*,

157 je.entry_type,

158 je.transaction_date,

159 coa.account_type_id

136 coa.account_type_id

160 FROM journal_entries je

137 FROM journal_entries je

161 JOIN transaction_headers tr ON je.transaction_id = tr.id

138 JOIN transaction_headers tr ON je.transaction_id = tr.id

162 JOIN chart_of_accounts coa ON je.account_id = coa.id

139 JOIN chart_of_accounts coa ON je.account_id = coa.id

163 WHERE tr.company_id = p_company_id

140 WHERE tr.company_id = p_company_id

164 AND je.is_deleted = FALSE

141 AND je.is_deleted = FALSE

165 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

142 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

166 )

143 )

167 SELECT

144 SELECT

168 CONCAT(fq.period, ' ', fq.year) AS period,

145 CONCAT(q.period, ' ', q.year),

169 fq.year,

146 q.year,

170 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)

147

            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),

171

                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS total_income,

148

            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),

172 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)

149 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),

173

                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,

150 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)

174 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)

151 FROM quarters q

175

                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,

152 JOIN filtered_je je ON EXTRACT(MONTH FROM je.transaction_date) BETWEEN q.start_month AND q.end_month

176 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)

153 AND EXTRACT(YEAR FROM je.transaction_date) = q.year

177

                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense

154 GROUP BY q.period, q.year

178 FROM fiscal_quarters fq

155 ORDER BY q.year, q.period;

179 LEFT JOIN filtered_je je

180 ON je.transaction_date BETWEEN fq.period_start AND fq.period_end

181 GROUP BY fq.period, fq.year

182 ORDER BY fq.year, fq.period;

183

156

184 ELSIF p_period_type = CONST_HALF_YEARLY THEN

157 ELSIF p_period_type = CONST_HALF_YEARLY THEN

185 RETURN QUERY

158 RETURN QUERY

186 WITH half_years AS (

159 WITH half_years AS (

187

            SELECT 'H1' AS period, v_financial_year_start AS period_start, make_date(v_finance_year_start::int, 9, 30) AS period_end, v_finance_year_start AS year

160 SELECT 'H1' AS period, 4 AS start_month, 9 AS end_month, v_finance_year_start AS year

188 UNION ALL

161 UNION ALL SELECT 'H2', 10, 12, v_finance_year_start

189 SELECT 'H2', make_date(v_finance_year_start::int, 10, 1), v_financial_year_end, v_finance_year_start

162 UNION ALL SELECT 'H2', 1, 3, v_finance_year_end

190 ),

163 ),

191 filtered_je AS (

164 filtered_je AS (

192 SELECT

165 SELECT

193 je.amount,

166 je.*,

194 je.entry_type,

195 je.transaction_date,

196 coa.account_type_id

167 coa.account_type_id

197 FROM journal_entries je

168 FROM journal_entries je

198 JOIN transaction_headers tr ON je.transaction_id = tr.id

169 JOIN transaction_headers tr ON je.transaction_id = tr.id

199 JOIN chart_of_accounts coa ON je.account_id = coa.id

170 JOIN chart_of_accounts coa ON je.account_id = coa.id

200 WHERE tr.company_id = p_company_id

171 WHERE tr.company_id = p_company_id

201 AND je.is_deleted = FALSE

172 AND je.is_deleted = FALSE

202 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

173 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

203 )

174 )

204 SELECT

175 SELECT

205 CONCAT(h.period, ' ', h.year) AS period,

176 CONCAT(h.period, ' ', h.year),

206 h.year,

177 h.year,

207 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)

178

            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),

208

                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS total_income,

179

            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),

209 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)

180 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),

210

                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,

181 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)

211 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)

212

                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,

213 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)

214

                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense

215 FROM half_years h

182 FROM half_years h

216 JOIN filtered_je je

183 JOIN filtered_je je ON EXTRACT(MONTH FROM je.transaction_date) BETWEEN h.start_month AND h.end_month

217 ON je.transaction_date BETWEEN h.period_start AND h.period_end

184 AND EXTRACT(YEAR FROM je.transaction_date) = h.year

218 GROUP BY h.period, h.year

185 GROUP BY h.period, h.year

219 ORDER BY h.year, h.period;

186 ORDER BY h.year, h.period;

220

187

221 ELSIF p_period_type = CONST_YEARLY THEN

188 ELSIF p_period_type = CONST_YEARLY THEN

222 RETURN QUERY

189 RETURN QUERY

223 WITH filtered_je AS (

190 WITH filtered_je AS (

224 SELECT

191 SELECT

225 je.amount,

192 je.*,

226 je.entry_type,

227 je.transaction_date,

228 coa.account_type_id

193 coa.account_type_id

229 FROM journal_entries je

194 FROM journal_entries je

230 JOIN transaction_headers tr ON je.transaction_id = tr.id

195 JOIN transaction_headers tr ON je.transaction_id = tr.id

231 JOIN chart_of_accounts coa ON je.account_id = coa.id

196 JOIN chart_of_accounts coa ON je.account_id = coa.id

232 WHERE tr.company_id = p_company_id

197 WHERE tr.company_id = p_company_id

233 AND je.is_deleted = FALSE

198 AND je.is_deleted = FALSE

234 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

199 AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end

235 )

200 )

236 SELECT

201 SELECT

237 CONCAT('Year ', v_finance_year_start) AS period,

202 CONCAT('Year ', EXTRACT(YEAR FROM je.transaction_date)),

238 v_finance_year_start AS year,

203 EXTRACT(YEAR FROM je.transaction_date),

239

            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0) AS total_income,

204

            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),

240

            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0) AS total_expense,

205

            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),

241

            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0) AS actual_income,

206 COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),

242

            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0) AS actual_expense

207 COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)

243 FROM filtered_je je;

208 FROM filtered_je je

209 GROUP BY EXTRACT(YEAR FROM je.transaction_date)

210 ORDER BY EXTRACT(YEAR FROM je.transaction_date);

244

211

245 ELSE

212 ELSE

246 RAISE EXCEPTION 'Unsupported period type %', p_period_type;

213 RAISE EXCEPTION 'Unsupported period type %', p_period_type;

247 END IF;

214 END IF;

248 END;

215 END;

249 $function$

216 $function$


                                -- Table: module_permissions
Exists in source, missing in target

-- Table: user_roles
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:end_date:timestamp without time zone:False::'0001-01-01 00:00:00'::timestamp without time zone:False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:organization_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:role_id:integer:False:::False|COL:start_date:timestamp without time zone:False::'0001-01-01 00:00:00'::timestamp without time zone:False|COL:user_id:uuid:False:::False|PK:|FK:created_by→users.id|FK:modified_by→users.id|FK:organization_id→organizations.id|FK:role_id→roles.id|FK:user_id→users.id|IDX:btree:nonunique:user_id,is_deleted,organization_id:|IDX:btree:unique:id:|IDX:btree:unique:user_id,role_id,organization_id:

-- TARGET SIGNATURE
COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:end_date:timestamp without time zone:False::'0001-01-01 00:00:00'::timestamp without time zone:False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:role_id:integer:False:::False|COL:start_date:timestamp without time zone:False::'0001-01-01 00:00:00'::timestamp without time zone:False|COL:user_id:uuid:False:::False|PK:|FK:created_by→users.id|FK:modified_by→users.id|FK:role_id→roles.id|FK:user_id→users.id|IDX:btree:unique:id:

-- SOURCE SCRIPT
CREATE TABLE "user_roles" ("user_id" uuid NOT NULL, "role_id" integer NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "end_date" timestamp without time zone DEFAULT '0001-01-01 00:00:00'::timestamp without time zone NOT NULL, "start_date" timestamp without time zone DEFAULT '0001-01-01 00:00:00'::timestamp without time zone NOT NULL, "organization_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "id" integer NOT NULL, PRIMARY KEY ("id"));

-- TARGET SCRIPT
CREATE TABLE "user_roles" ("id" integer NOT NULL, "user_id" uuid NOT NULL, "role_id" integer NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "end_date" timestamp without time zone DEFAULT '0001-01-01 00:00:00'::timestamp without time zone NOT NULL, "start_date" timestamp without time zone DEFAULT '0001-01-01 00:00:00'::timestamp without time zone NOT NULL, PRIMARY KEY ("id"));

-- Columns: MissingInTarget
ALTER TABLE "user_roles" ADD COLUMN "organization_id" uuid NOT NULL;

-- ForeignKeys: MissingInTarget
ALTER TABLE "user_roles" ADD CONSTRAINT "fk_user_roles_organization" FOREIGN KEY (organization_id) REFERENCES organizations(id);

-- Indexes: MissingInTarget
CREATE INDEX ix_user_roles_user_id_organization_id_is_deleted ON public.user_roles USING btree (user_id, organization_id, is_deleted)

-- Indexes: MissingInTarget
CREATE UNIQUE INDEX uq_user_roles_unique ON public.user_roles USING btree (user_id, role_id, organization_id)

-- Table: description_templates
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:deleted_on_utc:timestamp without time zone:True:::False|COL:id:integer:False::nextval('description_templates_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:name:text:False::''::text:False|COL:template_text:text:False:::False|PK:|IDX:btree:unique:id:

-- TARGET SIGNATURE
COL:id:integer:False::nextval('description_templates_id_seq'::regclass):False|COL:template_text:text:False:::False|PK:|IDX:btree:unique:id:

-- SOURCE SCRIPT
CREATE TABLE "description_templates" ("id" integer DEFAULT nextval('description_templates_id_seq'::regclass) NOT NULL, "template_text" text NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "name" text DEFAULT ''::text NOT NULL, PRIMARY KEY ("id"));

-- TARGET SCRIPT
CREATE TABLE "description_templates" ("id" integer DEFAULT nextval('description_templates_id_seq'::regclass) NOT NULL, "template_text" text NOT NULL, PRIMARY KEY ("id"));

-- Columns: MissingInTarget
ALTER TABLE "description_templates" ADD COLUMN "deleted_on_utc" timestamp without time zone ;

-- Columns: MissingInTarget
ALTER TABLE "description_templates" ADD COLUMN "is_deleted" boolean NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "description_templates" ADD COLUMN "name" text NOT NULL;

-- Table: role_permissions
Exists in source, missing in target

-- Table: chart_of_accounts
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:account_group_code:integer:False::0:False|COL:account_number:text:False:::False|COL:account_type_id:integer:False:::False|COL:alternative_name:text:True:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:current_balance:numeric:True::0.00:False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False::''::text:False|COL:id:uuid:False::gen_random_uuid():False|COL:is_default_account:boolean:False::false:False|COL:is_deleted:boolean:False::false:False|COL:is_ledger_total:boolean:False::false:False|COL:is_pg_bank_account:boolean:False::false:False|COL:is_show_outs:boolean:False::false:False|COL:is_tds_tcs:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:name:text:False:::False|COL:opening_balance:numeric:False::0.0:False|COL:organization_id:uuid:False:::False|COL:parent_account_id:uuid:True:::False|COL:second_group_code:integer:False::0:False|PK:|FK:account_type_id→account_types.id|FK:created_by→users.id|FK:modified_by→users.id|FK:organization_id→organizations.id|IDX:btree:unique:id:

-- TARGET SIGNATURE
COL:account_group_code:integer:False::0:False|COL:account_number:text:False:::False|COL:account_type_id:integer:False:::False|COL:alternative_name:text:True:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:current_balance:numeric:True::0.00:False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False::''::text:False|COL:id:uuid:False::gen_random_uuid():False|COL:is_default_account:boolean:False::false:False|COL:is_deleted:boolean:False::false:False|COL:is_ledger_total:boolean:False::false:False|COL:is_show_outs:boolean:False::false:False|COL:is_tds_tcs:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:name:text:False:::False|COL:opening_balance:numeric:False::0.0:False|COL:organization_id:uuid:False:::False|COL:parent_account_id:uuid:True:::False|COL:second_group_code:integer:False::0:False|PK:|FK:account_type_id→account_types.id|FK:created_by→users.id|FK:modified_by→users.id|FK:organization_id→organizations.id|IDX:btree:unique:id:

-- SOURCE SCRIPT
CREATE TABLE "chart_of_accounts" ("id" uuid DEFAULT gen_random_uuid() NOT NULL, "account_number" text NOT NULL, "name" text NOT NULL, "organization_id" uuid NOT NULL, "parent_account_id" uuid, "description" text DEFAULT ''::text NOT NULL, "account_type_id" integer NOT NULL, "account_group_code" integer DEFAULT 0 NOT NULL, "second_group_code" integer DEFAULT 0 NOT NULL, "alternative_name" text, "is_ledger_total" boolean DEFAULT false NOT NULL, "is_show_outs" boolean DEFAULT false NOT NULL, "is_tds_tcs" boolean DEFAULT false NOT NULL, "opening_balance" numeric(,) DEFAULT 0.0 NOT NULL, "current_balance" numeric(,) DEFAULT 0.00, "created_by" uuid NOT NULL, "modified_by" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "is_default_account" boolean DEFAULT false NOT NULL, "is_pg_bank_account" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id"));

-- TARGET SCRIPT
CREATE TABLE "chart_of_accounts" ("id" uuid DEFAULT gen_random_uuid() NOT NULL, "account_number" text NOT NULL, "name" text NOT NULL, "organization_id" uuid NOT NULL, "parent_account_id" uuid, "description" text DEFAULT ''::text NOT NULL, "account_type_id" integer NOT NULL, "account_group_code" integer DEFAULT 0 NOT NULL, "second_group_code" integer DEFAULT 0 NOT NULL, "alternative_name" text, "is_ledger_total" boolean DEFAULT false NOT NULL, "is_show_outs" boolean DEFAULT false NOT NULL, "is_tds_tcs" boolean DEFAULT false NOT NULL, "opening_balance" numeric(,) DEFAULT 0.0 NOT NULL, "current_balance" numeric(15,2) DEFAULT 0.00, "created_by" uuid NOT NULL, "modified_by" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "is_default_account" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id"));

-- Columns: MissingInTarget
ALTER TABLE "chart_of_accounts" ADD COLUMN "is_pg_bank_account" boolean NOT NULL;

-- Table: users
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:address_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:company_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:date_of_birth:timestamp without time zone:False::'0001-01-01'::date:False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:department_id:integer:False::0:False|COL:designation_id:integer:False::0:False|COL:email:character varying:False:256::False|COL:first_name:character varying:False:100::False|COL:id:uuid:False:::False|COL:is_deleted:boolean:False::false:False|COL:last_name:character varying:False:100::False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:note:text:True:::False|COL:password_hash:text:False:::False|COL:phone_number:character varying:False:15:''::character varying:False|COL:roles:array:True::array[]::text[]:False|COL:role_id:integer:True::0:False|COL:third_party_id:text:False::''::text:False|COL:user_name:text:False::''::text:False|PK:|FK:address_id→addresses.id|FK:created_by→users.id|FK:modified_by→users.id|IDX:btree:unique:email,phone_number:|IDX:btree:unique:email:|IDX:btree:unique:id:

-- TARGET SIGNATURE
COL:address_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:company_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:date_of_birth:timestamp without time zone:False::'0001-01-01'::date:False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:department_id:integer:False::0:False|COL:designation_id:integer:False::0:False|COL:email:character varying:False:256::False|COL:first_name:character varying:False:100::False|COL:id:uuid:False:::False|COL:is_deleted:boolean:False::false:False|COL:last_name:character varying:False:100::False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:note:text:True:::False|COL:password_hash:text:False:::False|COL:phone_number:character varying:False:15:''::character varying:False|COL:roles:array:True::array[]::text[]:False|COL:role_id:integer:True::0:False|COL:third_party_id:text:False::''::text:False|COL:user_name:text:False::''::text:False|PK:|FK:address_id→addresses.id|FK:created_by→users.id|FK:modified_by→users.id|IDX:btree:unique:email,phone_number:|IDX:btree:unique:id:

-- SOURCE SCRIPT
CREATE TABLE "users" ("id" uuid NOT NULL, "first_name" varchar(100) NOT NULL, "last_name" varchar(100) NOT NULL, "email" varchar(256) NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "password_hash" text NOT NULL, "third_party_id" text DEFAULT ''::text NOT NULL, "roles" ARRAY DEFAULT ARRAY[]::text[], "address_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "date_of_birth" timestamp without time zone DEFAULT '0001-01-01'::date NOT NULL, "note" text, "role_id" integer DEFAULT 0, "designation_id" integer DEFAULT 0 NOT NULL, "department_id" integer DEFAULT 0 NOT NULL, "phone_number" varchar(15) DEFAULT ''::character varying NOT NULL, "company_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "user_name" text DEFAULT ''::text NOT NULL, PRIMARY KEY ("id"));

-- TARGET SCRIPT
CREATE TABLE "users" ("id" uuid NOT NULL, "first_name" varchar(100) NOT NULL, "last_name" varchar(100) NOT NULL, "email" varchar(256) NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "password_hash" text NOT NULL, "third_party_id" text DEFAULT ''::text NOT NULL, "roles" ARRAY DEFAULT ARRAY[]::text[], "phone_number" varchar(15) DEFAULT ''::character varying NOT NULL, "address_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "date_of_birth" timestamp without time zone DEFAULT '0001-01-01'::date NOT NULL, "note" text, "role_id" integer DEFAULT 0, "designation_id" integer DEFAULT 0 NOT NULL, "department_id" integer DEFAULT 0 NOT NULL, "company_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "user_name" text DEFAULT ''::text NOT NULL, PRIMARY KEY ("id"));

-- Indexes: MissingInTarget
CREATE UNIQUE INDEX uq_users_email ON public.users USING btree (email)

-- Table: users_bk
Exists in source, missing in target

-- Table: v_permission_id
Exists in source, missing in target

-- Table: user_permissions
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:is_explicit:boolean:True::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:organization_id:uuid:True:::False|COL:permission_id:uuid:False:::False|COL:user_id:uuid:False:::False|FK:created_by→users.id|FK:modified_by→users.id|FK:organization_id→organizations.id|FK:permission_id→permissions.id|FK:user_id→users.id|IDX:btree:nonunique:user_id,is_deleted,organization_id:|IDX:btree:nonunique:user_id,permission_id,organization_id:|IDX:btree:unique:id:|IDX:btree:unique:user_id,permission_id,organization_id:

-- TARGET SIGNATURE
COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:organization_id:uuid:False:::False|COL:permission_id:uuid:False:::False|COL:user_id:uuid:False:::False|PK:|FK:created_by→users.id|FK:modified_by→users.id|FK:organization_id→organizations.id|FK:permission_id→permissions.id|IDX:btree:unique:id:|IDX:btree:unique:user_id,organization_id,permission_id:

-- SOURCE SCRIPT
CREATE TABLE "user_permissions" ("id" integer NOT NULL, "user_id" uuid NOT NULL, "permission_id" uuid NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "organization_id" uuid, "is_explicit" boolean DEFAULT false);

-- TARGET SCRIPT
CREATE TABLE "user_permissions" ("id" integer NOT NULL, "user_id" uuid NOT NULL, "organization_id" uuid NOT NULL, "permission_id" uuid NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, PRIMARY KEY ("id"));

-- Columns: MissingInTarget
ALTER TABLE "user_permissions" ADD COLUMN "is_explicit" boolean ;

-- ForeignKeys: MissingInTarget
ALTER TABLE "user_permissions" ADD CONSTRAINT "fk_user_permissions_users_user_id" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE RESTRICT;

-- Indexes: MissingInTarget
CREATE INDEX idx_user_permissions_active ON public.user_permissions USING btree (user_id, organization_id, permission_id) WHERE (is_deleted = false)

-- Indexes: MissingInTarget
CREATE INDEX ix_user_permissions_user_id_organization_id_is_deleted ON public.user_permissions USING btree (user_id, organization_id, is_deleted)

-- Indexes: MissingInTarget
CREATE UNIQUE INDEX uq_user_permissions ON public.user_permissions USING btree (user_id, organization_id, permission_id)

-- Indexes: MissingInSource
-- Optionally drop: DROP INDEX IF EXISTS "uq_user_permissions";

-- Table: bank_reconciliation_links
Exists in source, missing in target

-- Table: temp_paymnet_data
Exists in source, missing in target

-- Table: bank_reconciliation_stagings
Exists in source, missing in target

-- Table: payment_references
Exists in source, missing in target

-- Table: journal_narrations
Exists in source, missing in target

-- Table: transaction_header_2024_2025
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:is_reversed:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "transaction_header_2024_2025" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, "transaction_source_type" integer NOT NULL, "is_reversed" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "transaction_header_2024_2025" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "transaction_source_type" integer NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "transaction_header_2024_2025" ADD COLUMN "is_reversed" boolean NOT NULL;

-- Table: cron_dummy_log
Exists in source, missing in target

-- Table: journal_entries
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:True:::False|COL:dynamic_data:jsonb:True:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:journal_narration_id:bigint:False::0:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:entry_source_id→entry_sources.id|FK:journal_narration_id→journal_narrations.id|FK:transaction_date→transaction_header_2022_2023.id|FK:transaction_date→transaction_header_2022_2023.transaction_date|FK:transaction_date→transaction_header_2023_2024.id|FK:transaction_date→transaction_header_2023_2024.transaction_date|FK:transaction_date→transaction_header_2024_2025.id|FK:transaction_date→transaction_header_2024_2025.transaction_date|FK:transaction_date→transaction_header_2025_2026.id|FK:transaction_date→transaction_header_2025_2026.transaction_date|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_header_2022_2023.id|FK:transaction_id→transaction_header_2022_2023.transaction_date|FK:transaction_id→transaction_header_2023_2024.id|FK:transaction_id→transaction_header_2023_2024.transaction_date|FK:transaction_id→transaction_header_2024_2025.id|FK:transaction_id→transaction_header_2024_2025.transaction_date|FK:transaction_id→transaction_header_2025_2026.id|FK:transaction_id→transaction_header_2025_2026.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:False:::False|COL:dynamic_data:jsonb:False:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:description_template_id→description_templates.id|FK:entry_source_id→entry_sources.id|FK:transaction_date→transaction_header_2022_2023.id|FK:transaction_date→transaction_header_2022_2023.transaction_date|FK:transaction_date→transaction_header_2023_2024.id|FK:transaction_date→transaction_header_2023_2024.transaction_date|FK:transaction_date→transaction_header_2024_2025.id|FK:transaction_date→transaction_header_2024_2025.transaction_date|FK:transaction_date→transaction_header_2025_2026.id|FK:transaction_date→transaction_header_2025_2026.transaction_date|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_header_2022_2023.id|FK:transaction_id→transaction_header_2022_2023.transaction_date|FK:transaction_id→transaction_header_2023_2024.id|FK:transaction_id→transaction_header_2023_2024.transaction_date|FK:transaction_id→transaction_header_2024_2025.id|FK:transaction_id→transaction_header_2024_2025.transaction_date|FK:transaction_id→transaction_header_2025_2026.id|FK:transaction_id→transaction_header_2025_2026.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "journal_entries" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer, "dynamic_data" jsonb, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, "journal_narration_id" bigint DEFAULT 0 NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "journal_entries" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer NOT NULL, "dynamic_data" jsonb NOT NULL, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "journal_entries" ADD COLUMN "journal_narration_id" bigint NOT NULL;

-- ForeignKeys: MissingInTarget
ALTER TABLE "journal_entries" ADD CONSTRAINT "fk_journal_entries_journal_narration_id" FOREIGN KEY (journal_narration_id) REFERENCES journal_narrations(id);

-- ForeignKeys: MissingInSource
ALTER TABLE "journal_entries" ADD CONSTRAINT "fk_journal_entries_description_template_id" FOREIGN KEY (description_template_id) REFERENCES description_templates(id);

-- Table: transaction_header_2022_2023
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:is_reversed:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "transaction_header_2022_2023" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, "transaction_source_type" integer NOT NULL, "is_reversed" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "transaction_header_2022_2023" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "transaction_source_type" integer NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "transaction_header_2022_2023" ADD COLUMN "is_reversed" boolean NOT NULL;

-- Table: transaction_header_2023_2024
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:is_reversed:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "transaction_header_2023_2024" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, "transaction_source_type" integer NOT NULL, "is_reversed" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "transaction_header_2023_2024" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "transaction_source_type" integer NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "transaction_header_2023_2024" ADD COLUMN "is_reversed" boolean NOT NULL;

-- Table: bank_reconciliations
Exists in source, missing in target

-- Table: feature_toggles
Exists in source, missing in target

-- Table: user_permissions_backup
Exists in source, missing in target

-- Table: journal_entries_2022_2023
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:True:::False|COL:dynamic_data:jsonb:True:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:journal_narration_id:bigint:False::0:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:entry_source_id→entry_sources.id|FK:journal_narration_id→journal_narrations.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:False:::False|COL:dynamic_data:jsonb:False:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:description_template_id→description_templates.id|FK:entry_source_id→entry_sources.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "journal_entries_2022_2023" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer, "dynamic_data" jsonb, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, "journal_narration_id" bigint DEFAULT 0 NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "journal_entries_2022_2023" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer NOT NULL, "dynamic_data" jsonb NOT NULL, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "journal_entries_2022_2023" ADD COLUMN "journal_narration_id" bigint NOT NULL;

-- ForeignKeys: MissingInTarget
ALTER TABLE "journal_entries_2022_2023" ADD CONSTRAINT "fk_journal_entries_journal_narration_id" FOREIGN KEY (journal_narration_id) REFERENCES journal_narrations(id);

-- ForeignKeys: MissingInSource
ALTER TABLE "journal_entries_2022_2023" ADD CONSTRAINT "fk_journal_entries_description_template_id" FOREIGN KEY (description_template_id) REFERENCES description_templates(id);

-- Table: feature_toggle_overrides
Exists in source, missing in target

-- Table: user_permission_sync_runs
Exists in source, missing in target

-- Table: user_permission_sync_deltas
Exists in source, missing in target

-- Table: scope_types
Exists in source, missing in target

-- Table: journal_entries_2023_2024
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:True:::False|COL:dynamic_data:jsonb:True:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:journal_narration_id:bigint:False::0:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:entry_source_id→entry_sources.id|FK:journal_narration_id→journal_narrations.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:False:::False|COL:dynamic_data:jsonb:False:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:description_template_id→description_templates.id|FK:entry_source_id→entry_sources.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "journal_entries_2023_2024" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer, "dynamic_data" jsonb, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, "journal_narration_id" bigint DEFAULT 0 NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "journal_entries_2023_2024" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer NOT NULL, "dynamic_data" jsonb NOT NULL, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "journal_entries_2023_2024" ADD COLUMN "journal_narration_id" bigint NOT NULL;

-- ForeignKeys: MissingInTarget
ALTER TABLE "journal_entries_2023_2024" ADD CONSTRAINT "fk_journal_entries_journal_narration_id" FOREIGN KEY (journal_narration_id) REFERENCES journal_narrations(id);

-- ForeignKeys: MissingInSource
ALTER TABLE "journal_entries_2023_2024" ADD CONSTRAINT "fk_journal_entries_description_template_id" FOREIGN KEY (description_template_id) REFERENCES description_templates(id);

-- Table: journal_entries_2024_2025
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:True:::False|COL:dynamic_data:jsonb:True:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:journal_narration_id:bigint:False::0:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:entry_source_id→entry_sources.id|FK:journal_narration_id→journal_narrations.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:False:::False|COL:dynamic_data:jsonb:False:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:description_template_id→description_templates.id|FK:entry_source_id→entry_sources.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "journal_entries_2024_2025" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer, "dynamic_data" jsonb, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, "journal_narration_id" bigint DEFAULT 0 NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "journal_entries_2024_2025" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer NOT NULL, "dynamic_data" jsonb NOT NULL, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "journal_entries_2024_2025" ADD COLUMN "journal_narration_id" bigint NOT NULL;

-- ForeignKeys: MissingInTarget
ALTER TABLE "journal_entries_2024_2025" ADD CONSTRAINT "fk_journal_entries_journal_narration_id" FOREIGN KEY (journal_narration_id) REFERENCES journal_narrations(id);

-- ForeignKeys: MissingInSource
ALTER TABLE "journal_entries_2024_2025" ADD CONSTRAINT "fk_journal_entries_description_template_id" FOREIGN KEY (description_template_id) REFERENCES description_templates(id);

-- Table: journal_entries_2025_2026
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:True:::False|COL:dynamic_data:jsonb:True:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:journal_narration_id:bigint:False::0:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:entry_source_id→entry_sources.id|FK:journal_narration_id→journal_narrations.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:account_id:uuid:True:::False|COL:amount:numeric:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description_template_id:integer:False:::False|COL:dynamic_data:jsonb:False:::False|COL:entry_source_id:integer:False:::False|COL:entry_type:character:False:1::False|COL:id:bigint:False::nextval('journal_entries_id_seq'::regclass):False|COL:is_deleted:boolean:False::false:False|COL:transaction_date:date:False:::False|COL:transaction_id:bigint:False:::False|PK:|PK:|FK:account_id→chart_of_accounts.id|FK:description_template_id→description_templates.id|FK:entry_source_id→entry_sources.id|FK:transaction_date→transaction_headers.id|FK:transaction_date→transaction_headers.transaction_date|FK:transaction_id→transaction_headers.id|FK:transaction_id→transaction_headers.transaction_date|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "journal_entries_2025_2026" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer, "dynamic_data" jsonb, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, "journal_narration_id" bigint DEFAULT 0 NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "journal_entries_2025_2026" ("id" bigint DEFAULT nextval('journal_entries_id_seq'::regclass) NOT NULL, "transaction_id" bigint NOT NULL, "transaction_date" date NOT NULL, "amount" numeric(15,2) NOT NULL, "entry_type" character NOT NULL, "description_template_id" integer NOT NULL, "dynamic_data" jsonb NOT NULL, "entry_source_id" integer NOT NULL, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "account_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "journal_entries_2025_2026" ADD COLUMN "journal_narration_id" bigint NOT NULL;

-- ForeignKeys: MissingInTarget
ALTER TABLE "journal_entries_2025_2026" ADD CONSTRAINT "fk_journal_entries_journal_narration_id" FOREIGN KEY (journal_narration_id) REFERENCES journal_narrations(id);

-- ForeignKeys: MissingInSource
ALTER TABLE "journal_entries_2025_2026" ADD CONSTRAINT "fk_journal_entries_description_template_id" FOREIGN KEY (description_template_id) REFERENCES description_templates(id);

-- Table: actions
Exists in source, missing in target

-- Table: feature_toggle_audits
Exists in source, missing in target

-- Table: organization_accounts
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:accounts_payable_account_id:uuid:False:::False|COL:accounts_receivable_account_id:uuid:False:::False|COL:bad_debt_expense_account_id:uuid:True:::False|COL:bank_charges_account_id:uuid:True:::False|COL:cgst_payable_account_id:uuid:False:::False|COL:cgst_receivable_account_id:uuid:False:::False|COL:cost_of_goods_sold_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:True:::False|COL:customer_advance_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:customer_security_deposit_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:depreciation_expense_account_id:uuid:True:::False|COL:discounts_given_account_id:uuid:True:::False|COL:discounts_received_account_id:uuid:True:::False|COL:employee_advance_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:employee_loan_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:esi_payable_employee_contribution_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:esi_payable_employer_contribution_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:foreign_exchange_gain_loss_account_id:uuid:True:::False|COL:id:bigint:False:::False|COL:igst_payable_account_id:uuid:False:::False|COL:igst_receivable_account_id:uuid:False:::False|COL:interest_expense_account_id:uuid:True:::False|COL:interest_income_account_id:uuid:True:::False|COL:inventory_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:is_deleted:boolean:False::false:False|COL:lwf_payable_employee_contribution_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:lwf_payable_employer_contribution_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:opening_balance_equity_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:organization_id:uuid:False:::False|COL:penalty_receivable_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:pf_payable_employee_contribution_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:pf_payable_employer_contribution_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:purchase_tax_receivable_account_id:uuid:True:::False|COL:round_off_gain_account_id:uuid:False:::False|COL:round_off_loss_account_id:uuid:True:::False|COL:salary_expense_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:salary_payable_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:sales_revenue_account_id:uuid:False:::False|COL:sales_tax_payable_account_id:uuid:True:::False|COL:sgst_payable_account_id:uuid:False:::False|COL:sgst_receivable_account_id:uuid:False:::False|COL:tds_on_contractors_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:tds_on_salaries_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:tds_payable_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:tds_receivable_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:vendor_advance_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:vendor_security_deposit_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|PK:|FK:accounts_payable_account_id→chart_of_accounts.id|FK:accounts_receivable_account_id→chart_of_accounts.id|FK:bad_debt_expense_account_id→chart_of_accounts.id|FK:bank_charges_account_id→chart_of_accounts.id|FK:cgst_payable_account_id→chart_of_accounts.id|FK:cgst_receivable_account_id→chart_of_accounts.id|FK:created_by→users.id|FK:depreciation_expense_account_id→chart_of_accounts.id|FK:discounts_given_account_id→chart_of_accounts.id|FK:discounts_received_account_id→chart_of_accounts.id|FK:foreign_exchange_gain_loss_account_id→chart_of_accounts.id|FK:igst_payable_account_id→chart_of_accounts.id|FK:igst_receivable_account_id→chart_of_accounts.id|FK:interest_expense_account_id→chart_of_accounts.id|FK:interest_income_account_id→chart_of_accounts.id|FK:modified_by→users.id|FK:organization_id→organizations.id|FK:purchase_tax_receivable_account_id→chart_of_accounts.id|FK:round_off_gain_account_id→chart_of_accounts.id|FK:round_off_loss_account_id→chart_of_accounts.id|FK:sales_revenue_account_id→chart_of_accounts.id|FK:sales_tax_payable_account_id→chart_of_accounts.id|FK:sgst_payable_account_id→chart_of_accounts.id|FK:sgst_receivable_account_id→chart_of_accounts.id|IDX:btree:unique:id:

-- TARGET SIGNATURE
COL:accounts_payable_account_id:uuid:False:::False|COL:accounts_receivable_account_id:uuid:False:::False|COL:bad_debt_expense_account_id:uuid:True:::False|COL:bank_charges_account_id:uuid:True:::False|COL:cgst_payable_account_id:uuid:False:::False|COL:cgst_receivable_account_id:uuid:False:::False|COL:cost_of_goods_sold_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:depreciation_expense_account_id:uuid:True:::False|COL:discounts_given_account_id:uuid:True:::False|COL:discounts_received_account_id:uuid:True:::False|COL:foreign_exchange_gain_loss_account_id:uuid:True:::False|COL:id:bigint:False:::False|COL:igst_payable_account_id:uuid:False:::False|COL:igst_receivable_account_id:uuid:False:::False|COL:interest_expense_account_id:uuid:True:::False|COL:interest_income_account_id:uuid:True:::False|COL:inventory_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:organization_id:uuid:False:::False|COL:penalty_receivable_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:purchase_tax_receivable_account_id:uuid:True:::False|COL:round_off_gain_account_id:uuid:False:::False|COL:round_off_loss_account_id:uuid:True:::False|COL:salary_expense_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:salary_payable_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:sales_revenue_account_id:uuid:False:::False|COL:sales_tax_payable_account_id:uuid:True:::False|COL:sgst_payable_account_id:uuid:False:::False|COL:sgst_receivable_account_id:uuid:False:::False|COL:tds_payable_account_id:uuid:False::'00000000-0000-0000-0000-000000000000'::uuid:False|COL:tds_receivable_account_id:uuid:True::'00000000-0000-0000-0000-000000000000'::uuid:False|PK:|FK:accounts_payable_account_id→chart_of_accounts.id|FK:accounts_receivable_account_id→chart_of_accounts.id|FK:bad_debt_expense_account_id→chart_of_accounts.id|FK:bank_charges_account_id→chart_of_accounts.id|FK:cgst_payable_account_id→chart_of_accounts.id|FK:cgst_receivable_account_id→chart_of_accounts.id|FK:created_by→users.id|FK:depreciation_expense_account_id→chart_of_accounts.id|FK:discounts_given_account_id→chart_of_accounts.id|FK:discounts_received_account_id→chart_of_accounts.id|FK:foreign_exchange_gain_loss_account_id→chart_of_accounts.id|FK:igst_payable_account_id→chart_of_accounts.id|FK:igst_receivable_account_id→chart_of_accounts.id|FK:interest_expense_account_id→chart_of_accounts.id|FK:interest_income_account_id→chart_of_accounts.id|FK:modified_by→users.id|FK:organization_id→organizations.id|FK:purchase_tax_receivable_account_id→chart_of_accounts.id|FK:round_off_gain_account_id→chart_of_accounts.id|FK:round_off_loss_account_id→chart_of_accounts.id|FK:sales_revenue_account_id→chart_of_accounts.id|FK:sales_tax_payable_account_id→chart_of_accounts.id|FK:sgst_payable_account_id→chart_of_accounts.id|FK:sgst_receivable_account_id→chart_of_accounts.id|IDX:btree:unique:id:

-- SOURCE SCRIPT
CREATE TABLE "organization_accounts" ("id" bigint NOT NULL, "organization_id" uuid NOT NULL, "accounts_receivable_account_id" uuid NOT NULL, "accounts_payable_account_id" uuid NOT NULL, "sales_revenue_account_id" uuid NOT NULL, "cgst_receivable_account_id" uuid NOT NULL, "sgst_receivable_account_id" uuid NOT NULL, "igst_receivable_account_id" uuid NOT NULL, "cgst_payable_account_id" uuid NOT NULL, "sgst_payable_account_id" uuid NOT NULL, "igst_payable_account_id" uuid NOT NULL, "round_off_gain_account_id" uuid NOT NULL, "round_off_loss_account_id" uuid, "sales_tax_payable_account_id" uuid, "purchase_tax_receivable_account_id" uuid, "discounts_given_account_id" uuid, "discounts_received_account_id" uuid, "interest_income_account_id" uuid, "interest_expense_account_id" uuid, "depreciation_expense_account_id" uuid, "bad_debt_expense_account_id" uuid, "bank_charges_account_id" uuid, "foreign_exchange_gain_loss_account_id" uuid, "created_on_utc" timestamp without time zone, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "cost_of_goods_sold_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "inventory_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "salary_expense_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "salary_payable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "tds_receivable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "penalty_receivable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "tds_payable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "customer_advance_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "customer_security_deposit_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "employee_advance_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "employee_loan_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "vendor_advance_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "vendor_security_deposit_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "esi_payable_employee_contribution_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "esi_payable_employer_contribution_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "lwf_payable_employee_contribution_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "lwf_payable_employer_contribution_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "pf_payable_employee_contribution_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "pf_payable_employer_contribution_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "tds_on_contractors_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "opening_balance_equity_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "tds_on_salaries_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, PRIMARY KEY ("id"));

-- TARGET SCRIPT
CREATE TABLE "organization_accounts" ("id" bigint NOT NULL, "organization_id" uuid NOT NULL, "accounts_receivable_account_id" uuid NOT NULL, "accounts_payable_account_id" uuid NOT NULL, "sales_revenue_account_id" uuid NOT NULL, "cgst_receivable_account_id" uuid NOT NULL, "sgst_receivable_account_id" uuid NOT NULL, "igst_receivable_account_id" uuid NOT NULL, "cgst_payable_account_id" uuid NOT NULL, "sgst_payable_account_id" uuid NOT NULL, "igst_payable_account_id" uuid NOT NULL, "round_off_gain_account_id" uuid NOT NULL, "round_off_loss_account_id" uuid, "sales_tax_payable_account_id" uuid, "purchase_tax_receivable_account_id" uuid, "discounts_given_account_id" uuid, "discounts_received_account_id" uuid, "interest_income_account_id" uuid, "interest_expense_account_id" uuid, "depreciation_expense_account_id" uuid, "bad_debt_expense_account_id" uuid, "bank_charges_account_id" uuid, "foreign_exchange_gain_loss_account_id" uuid, "created_on_utc" timestamp without time zone, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "cost_of_goods_sold_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "inventory_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "salary_expense_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "salary_payable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "tds_receivable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid, "penalty_receivable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, "tds_payable_account_id" uuid DEFAULT '00000000-0000-0000-0000-000000000000'::uuid NOT NULL, PRIMARY KEY ("id"));

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "customer_advance_account_id" uuid ;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "customer_security_deposit_account_id" uuid ;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "employee_advance_account_id" uuid ;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "employee_loan_account_id" uuid ;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "vendor_advance_account_id" uuid ;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "vendor_security_deposit_account_id" uuid ;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "esi_payable_employee_contribution_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "esi_payable_employer_contribution_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "lwf_payable_employee_contribution_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "lwf_payable_employer_contribution_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "pf_payable_employee_contribution_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "pf_payable_employer_contribution_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "tds_on_contractors_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "opening_balance_equity_account_id" uuid NOT NULL;

-- Columns: MissingInTarget
ALTER TABLE "organization_accounts" ADD COLUMN "tds_on_salaries_account_id" uuid NOT NULL;

-- Table: bank_statements
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:balance:numeric:True:::False|COL:bank_id:uuid:False:::False|COL:branch_code:character varying:True:20::False|COL:cheque_number:character varying:True:50::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:credit_amount:numeric:True:::False|COL:debit_amount:numeric:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:has_reconciled:boolean:False::false:False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:organization_id:uuid:False:::False|COL:txn_date:timestamp without time zone:False:::False|COL:value_date:timestamp without time zone:False:::False|PK:|IDX:btree:unique:id:

-- TARGET SIGNATURE
COL:balance:numeric:True:::False|COL:bank_id:integer:False:::False|COL:branch_code:character varying:True:20::False|COL:cheque_number:character varying:True:50::False|COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:credit_amount:numeric:True:::False|COL:debit_amount:numeric:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:has_reconciled:boolean:False::false:False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:txn_date:date:False:::False|COL:value_date:date:False:::False|PK:|IDX:btree:unique:id:

-- SOURCE SCRIPT
CREATE TABLE "bank_statements" ("id" integer NOT NULL, "organization_id" uuid NOT NULL, "bank_id" uuid NOT NULL, "txn_date" timestamp without time zone NOT NULL, "cheque_number" varchar(50), "description" text NOT NULL, "value_date" timestamp without time zone NOT NULL, "branch_code" varchar(20), "debit_amount" numeric(14,2), "credit_amount" numeric(14,2), "balance" numeric(14,2), "has_reconciled" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "modified_by" uuid, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id"));

-- TARGET SCRIPT
CREATE TABLE "bank_statements" ("id" integer NOT NULL, "company_id" uuid NOT NULL, "bank_id" integer NOT NULL, "txn_date" date NOT NULL, "cheque_number" varchar(50), "description" text NOT NULL, "value_date" date NOT NULL, "branch_code" varchar(20), "debit_amount" numeric(14,2), "credit_amount" numeric(14,2), "balance" numeric(14,2), "has_reconciled" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "created_on_utc" timestamp without time zone NOT NULL, "modified_by" uuid, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id"));

-- Columns: MissingInTarget
ALTER TABLE "bank_statements" ADD COLUMN "organization_id" uuid NOT NULL;

-- Table: audit_queries
Exists in source, missing in target

-- Table: audit_query_responses
Exists in source, missing in target

-- Table: audit_query_statuses
Exists in source, missing in target

-- Table: transaction_header_2025_2026
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:is_reversed:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "transaction_header_2025_2026" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, "transaction_source_type" integer NOT NULL, "is_reversed" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "transaction_header_2025_2026" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "transaction_source_type" integer NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "transaction_header_2025_2026" ADD COLUMN "is_reversed" boolean NOT NULL;

-- Table: transaction_headers
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:is_reversed:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- TARGET SIGNATURE
COL:company_id:uuid:False:::False|COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:customer_id:uuid:True:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:description:text:False:::False|COL:document_id:uuid:True:::False|COL:document_number:text:False:::False|COL:employee_id:uuid:True:::False|COL:id:bigint:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:status_id:integer:False:::False|COL:transaction_date:timestamp without time zone:False:::False|COL:transaction_source_type:integer:False:::False|COL:vendor_id:uuid:True:::False|PK:|PK:|FK:company_id→companies.id|FK:created_by→users.id|FK:customer_id→customers.id|FK:modified_by→users.id|FK:transaction_source_type→transaction_source_types.id|FK:vendor_id→vendors.id|IDX:btree:unique:id,transaction_date:

-- SOURCE SCRIPT
CREATE TABLE "transaction_headers" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, "transaction_source_type" integer NOT NULL, "is_reversed" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id", "transaction_date"));

-- TARGET SCRIPT
CREATE TABLE "transaction_headers" ("id" bigint NOT NULL, "company_id" uuid NOT NULL, "transaction_date" timestamp without time zone NOT NULL, "transaction_source_type" integer NOT NULL, "status_id" integer NOT NULL, "document_number" text NOT NULL, "description" text NOT NULL, "customer_id" uuid, "vendor_id" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "employee_id" uuid, "document_id" uuid, PRIMARY KEY ("id", "transaction_date"));

-- Columns: MissingInTarget
ALTER TABLE "transaction_headers" ADD COLUMN "is_reversed" boolean NOT NULL;

-- Table: messages
Exists in source, missing in target

-- Table: reconciliation_statuses
Exists in source, missing in target

-- Table: transaction_headers_19_05_25
Exists in source, missing in target

-- Table: transaction_headers_bk_20_5_25
Exists in source, missing in target

-- Table: transaction_source_types
-- StructuralDiff: Mismatch
-- SOURCE SIGNATURE
COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:name:text:False:::False|COL:sort_order:integer:False::100:False|PK:|IDX:btree:unique:id:

-- TARGET SIGNATURE
COL:created_by:uuid:False:::False|COL:created_on_utc:timestamp without time zone:False:::False|COL:deleted_on_utc:timestamp without time zone:True:::False|COL:id:integer:False:::False|COL:is_deleted:boolean:False::false:False|COL:modified_by:uuid:True:::False|COL:modified_on_utc:timestamp without time zone:True:::False|COL:name:text:False:::False|PK:|IDX:btree:unique:id:

-- SOURCE SCRIPT
CREATE TABLE "transaction_source_types" ("id" integer NOT NULL, "name" text NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, "sort_order" integer DEFAULT 100 NOT NULL, PRIMARY KEY ("id"));

-- TARGET SCRIPT
CREATE TABLE "transaction_source_types" ("id" integer NOT NULL, "name" text NOT NULL, "created_by" uuid NOT NULL, "modified_by" uuid, "created_on_utc" timestamp without time zone NOT NULL, "modified_on_utc" timestamp without time zone, "deleted_on_utc" timestamp without time zone, "is_deleted" boolean DEFAULT false NOT NULL, PRIMARY KEY ("id"));

-- Columns: MissingInTarget
ALTER TABLE "transaction_source_types" ADD COLUMN "sort_order" integer NOT NULL;

-- Table: employees
Exists in source, missing in target

-- Table: email_notification_rules
Exists in source, missing in target

-- Table: email_audit_logs
Exists in source, missing in target

-- Table: d_permission_details
-- CreateScript: MissingInSource
CREATE TABLE "d_permission_details" ("id" uuid NOT NULL, "name" text NOT NULL, "tree_name" text NOT NULL, PRIMARY KEY ("id"));

-- PrimaryKeys: MissingInSource
ALTER TABLE "d_permission_details" ADD CONSTRAINT "pk_d_permission_details" PRIMARY KEY (id);

-- Columns: MissingInSource
ALTER TABLE "d_permission_details" ADD COLUMN "id" uuid NOT NULL;

-- Columns: MissingInSource
ALTER TABLE "d_permission_details" ADD COLUMN "name" text NOT NULL;

-- Columns: MissingInSource
ALTER TABLE "d_permission_details" ADD COLUMN "tree_name" text NOT NULL;

-- Indexes: MissingInSource
CREATE UNIQUE INDEX pk_d_permission_details ON public.d_permission_details USING btree (id)

-- Table: organizations_to_be_cleaned
-- CreateScript: MissingInSource
CREATE TABLE "organizations_to_be_cleaned" ("id" uuid, "name" text);

-- Columns: MissingInSource
ALTER TABLE "organizations_to_be_cleaned" ADD COLUMN "id" uuid ;

-- Columns: MissingInSource
ALTER TABLE "organizations_to_be_cleaned" ADD COLUMN "name" text ;

-- Table: permission_templates
-- CreateScript: MissingInSource
CREATE TABLE "permission_templates" ("id" integer NOT NULL, "name" varchar(100) NOT NULL, PRIMARY KEY ("id"));

-- PrimaryKeys: MissingInSource
ALTER TABLE "permission_templates" ADD CONSTRAINT "pk_permission_templates" PRIMARY KEY (id);

-- Columns: MissingInSource
ALTER TABLE "permission_templates" ADD COLUMN "id" integer NOT NULL;

-- Columns: MissingInSource
ALTER TABLE "permission_templates" ADD COLUMN "name" character varying NOT NULL;

-- Indexes: MissingInSource
CREATE UNIQUE INDEX pk_permission_templates ON public.permission_templates USING btree (id)

-- Table: permission_template_mappings
-- CreateScript: MissingInSource
CREATE TABLE "permission_template_mappings" ("id" integer NOT NULL, "permission_template_id" integer NOT NULL, "permission_id" uuid NOT NULL, PRIMARY KEY ("id"));

-- PrimaryKeys: MissingInSource
ALTER TABLE "permission_template_mappings" ADD CONSTRAINT "pk_permission_template_mappings" PRIMARY KEY (id);

-- Columns: MissingInSource
ALTER TABLE "permission_template_mappings" ADD COLUMN "id" integer NOT NULL;

-- Columns: MissingInSource
ALTER TABLE "permission_template_mappings" ADD COLUMN "permission_template_id" integer NOT NULL;

-- Columns: MissingInSource
ALTER TABLE "permission_template_mappings" ADD COLUMN "permission_id" uuid NOT NULL;

-- ForeignKeys: MissingInSource
ALTER TABLE "permission_template_mappings" ADD CONSTRAINT "fk_permission_template_mappings_permission_templates_permissio" FOREIGN KEY (permission_template_id) REFERENCES permission_templates(id) ON DELETE CASCADE;

-- Indexes: MissingInSource
CREATE INDEX ix_permission_template_mappings_permission_template_id ON public.permission_template_mappings USING btree (permission_template_id)

-- Indexes: MissingInSource
CREATE UNIQUE INDEX pk_permission_template_mappings ON public.permission_template_mappings USING btree (id)

-- Function: pgp_sym_decrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_sym_decrypt_bytea(bytea, text, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_decrypt_bytea$function$

-- Function: pgp_pub_encrypt
CREATE OR REPLACE FUNCTION public.pgp_pub_encrypt(text, bytea)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_encrypt_text$function$

-- Function: pgp_pub_encrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_pub_encrypt_bytea(bytea, bytea)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_encrypt_bytea$function$

-- Function: pgp_pub_encrypt
CREATE OR REPLACE FUNCTION public.pgp_pub_encrypt(text, bytea, text)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_encrypt_text$function$

-- Function: pgp_pub_decrypt
CREATE OR REPLACE FUNCTION public.pgp_pub_decrypt(bytea, bytea, text)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_decrypt_text$function$

-- Function: pgp_pub_decrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_pub_decrypt_bytea(bytea, bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_decrypt_bytea$function$

-- Function: pgp_pub_decrypt
CREATE OR REPLACE FUNCTION public.pgp_pub_decrypt(bytea, bytea, text, text)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_decrypt_text$function$

-- Function: pgp_pub_decrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_pub_decrypt_bytea(bytea, bytea, text, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_decrypt_bytea$function$

-- Function: pgp_key_id
CREATE OR REPLACE FUNCTION public.pgp_key_id(bytea)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_key_id_w$function$

-- Function: armor
CREATE OR REPLACE FUNCTION public.armor(bytea)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_armor$function$

-- Function: armor
CREATE OR REPLACE FUNCTION public.armor(bytea, text[], text[])
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_armor$function$

-- Function: dearmor
CREATE OR REPLACE FUNCTION public.dearmor(text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_dearmor$function$

-- Function: pgp_armor_headers
CREATE OR REPLACE FUNCTION public.pgp_armor_headers(text, OUT key text, OUT value text)
 RETURNS SETOF record
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_armor_headers$function$

-- Function: fips_mode
CREATE OR REPLACE FUNCTION public.fips_mode()
 RETURNS boolean
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_check_fipsmode$function$

-- Function: uuid_nil
CREATE OR REPLACE FUNCTION public.uuid_nil()
 RETURNS uuid
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_nil$function$

-- Function: uuid_ns_dns
CREATE OR REPLACE FUNCTION public.uuid_ns_dns()
 RETURNS uuid
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_ns_dns$function$

-- Function: uuid_ns_url
CREATE OR REPLACE FUNCTION public.uuid_ns_url()
 RETURNS uuid
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_ns_url$function$

-- Function: uuid_ns_oid
CREATE OR REPLACE FUNCTION public.uuid_ns_oid()
 RETURNS uuid
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_ns_oid$function$

-- Function: uuid_ns_x500
CREATE OR REPLACE FUNCTION public.uuid_ns_x500()
 RETURNS uuid
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_ns_x500$function$

-- Function: uuid_generate_v1
CREATE OR REPLACE FUNCTION public.uuid_generate_v1()
 RETURNS uuid
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_generate_v1$function$

-- Function: uuid_generate_v1mc
CREATE OR REPLACE FUNCTION public.uuid_generate_v1mc()
 RETURNS uuid
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_generate_v1mc$function$

-- Function: uuid_generate_v3
CREATE OR REPLACE FUNCTION public.uuid_generate_v3(namespace uuid, name text)
 RETURNS uuid
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_generate_v3$function$

-- Function: uuid_generate_v4
CREATE OR REPLACE FUNCTION public.uuid_generate_v4()
 RETURNS uuid
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_generate_v4$function$

-- Function: uuid_generate_v5
CREATE OR REPLACE FUNCTION public.uuid_generate_v5(namespace uuid, name text)
 RETURNS uuid
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/uuid-ossp', $function$uuid_generate_v5$function$

-- Function: generate_permission_description
CREATE OR REPLACE FUNCTION public.generate_permission_description(p_name text)
 RETURNS text
 LANGUAGE plpgsql
AS $function$
DECLARE
    parts text[];
    module text;
    tail text[];
    action text;
    object_tokens text[];
    object_raw text;
    object_phrase text;
    is_myspace boolean := false;

    -- scratch vars for “humanize” and “pluralize”
    t text;
    obj_lc text;
BEGIN
    -- Expect Dhanman.<Module>...
    parts := regexp_split_to_array(p_name, '\.');
    IF array_length(parts, 1) IS NULL OR parts[1] <> 'Dhanman' THEN
        RETURN NULL; -- not our namespace
    END IF;

    module := parts[2];
    is_myspace := (module = 'MySpace');

    IF array_length(parts, 1) < 3 THEN
        -- e.g., Dhanman.Read / Dhanman.Write / Dhanman.Delete
        RETURN trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g')) || ' permission';
    END IF;

    tail := parts[3:array_length(parts,1)]; -- everything after module

    -- detect multi-word actions first
    IF tail[array_length(tail,1)] = 'SendForApproval' THEN
        action := 'SendForApproval';
        IF array_length(tail,1) > 1 THEN
          object_tokens := tail[1:array_length(tail,1)-1];
        ELSE
          object_tokens := ARRAY[]::text[];
        END IF;

    ELSIF tail[array_length(tail,1)] IN ('IdRead','TokenRead') THEN
        action := 'Read';
        IF array_length(tail,1) > 1 THEN
          object_tokens := tail[1:array_length(tail,1)-1];
        ELSE
          object_tokens := ARRAY[]::text[];
        END IF;

    ELSE
        -- simple actions (last token)
        IF tail[array_length(tail,1)] IN ('Read','Write','Delete','Approve','Cancel','Reject','Resolve','Assign','Copy','Pay','Import') THEN
            action := tail[array_length(tail,1)];
            IF array_length(tail,1) > 1 THEN
              object_tokens := tail[1:array_length(tail,1)-1];
            ELSE
              object_tokens := ARRAY[]::text[];
            END IF;
        ELSE
            -- No explicit action => treat the last token as (maybe) object and assume base Read on module
            action := NULL;
            object_tokens := tail;
        END IF;
    END IF;

    -- join tokens with '.' to get a raw object handle
    object_raw := NULL;
    IF object_tokens IS NOT NULL AND array_length(object_tokens,1) IS NOT NULL THEN
        SELECT string_agg(x, '.' ORDER BY ord)
        INTO object_raw
        FROM (
            SELECT object_tokens[i] AS x, i AS ord
            FROM generate_subscripts(object_tokens,1) AS i
        ) s;
    END IF;

    -- If action is NULL, try to interpret tail as a “Read/Write/Delete” on module (rare fallback)
    IF action IS NULL THEN
        IF object_raw ILIKE 'Read' THEN
            t := trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'));
            RETURN 'Read ' || lower(t) || ' data';
        ELSIF object_raw ILIKE 'Write' THEN
            t := trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'));
            RETURN 'Add/Update ' || lower(t) || ' data';
        ELSIF object_raw ILIKE 'Delete' THEN
            RETURN 'Delete general data';
        END IF;
        -- else continue with generic handling below
    END IF;

    -- ===== normalize object to a nicer phrase =====
    object_phrase := NULL;
    IF object_raw IS NOT NULL AND object_raw <> '' THEN
        obj_lc := lower(object_raw);

        -- specific aliases
        IF obj_lc ~* '^basic(\.read|\.write|\.delete)?$' THEN
            object_phrase := 'Basic Info';
        ELSIF obj_lc LIKE 'ticketstatus%' THEN
            object_phrase := 'Ticket Status';
        ELSIF obj_lc = 'invoicetemplate' THEN
            object_phrase := 'Invoice Template';
        ELSIF obj_lc = 'groupedinvoice' THEN
            object_phrase := 'Grouped Invoice';
        ELSIF obj_lc = 'recurringinvoice' THEN
            object_phrase := 'Recurring Invoice';
        ELSIF obj_lc = 'customeraccountconfig' THEN
            object_phrase := 'Customer Account Configuration';
        ELSIF obj_lc = 'vendoraccountconfig' THEN
            object_phrase := 'Vendor Account Configuration';
        ELSIF obj_lc = 'bankstatement' THEN
            object_phrase := 'Bank Statement';
        ELSIF obj_lc = 'banktransfer' THEN
            object_phrase := 'Bank Transfer';
        ELSIF obj_lc = 'fixeddeposit' THEN
            object_phrase := 'Fixed Deposit';
        ELSE
            -- generic humanize: add spaces before capitals
            object_phrase := trim(both ' ' FROM regexp_replace(object_raw, '([a-z])([A-Z])', '\1 \2', 'g'));
        END IF;
    END IF;

    -- quick helpers inlined:
    -- humanize(module)
    t := trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'));
    -- module phrase
    t := t || ' module';

    -- MySpace special-casing (root objects)
    IF is_myspace AND (object_phrase IS NULL OR object_phrase = '') THEN
        IF action = 'Read' THEN
            RETURN 'View own My Space data. (myspace)';
        ELSIF action = 'Write' THEN
            RETURN 'Create or update own data. (myspace)';
        ELSIF action = 'Delete' THEN
            RETURN 'Delete own entries. (myspace)';
        END IF;
    END IF;

    -- pluralize (very naive) if we need a plural in messages
    -- compute plural into obj_lc (reuse var)
    IF object_phrase IS NOT NULL AND object_phrase <> '' THEN
        obj_lc := lower(object_phrase);
        -- don’t pluralize these:
        IF obj_lc NOT IN ('info','data','ledger','cash flow','journal','basicinfo','basic info') THEN
            IF obj_lc !~ '(s|x|z|ch|sh)$' THEN
                object_phrase := object_phrase || 's';
            END IF;
        END IF;
    END IF;

    -- Render phrases by action
    IF is_myspace THEN
        -- MySpace + specific objects
        IF action = 'Read' AND object_phrase IS NOT NULL THEN
            IF lower(object_phrase) IN ('user', 'users') THEN
                RETURN 'View user (own) details. (myspace)';
            ELSIF lower(object_phrase) IN ('due','dues') THEN
                RETURN 'View dues summary. (myspace)';
            ELSE
                RETURN 'View own ' || lower(object_phrase) || '. (myspace)';
            END IF;
        END IF;
        -- For other MySpace actions on specific objects, fall through to generic wording below
    END IF;

    -- rebuild a fresh humanized module text for generic lines
    t := trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'));
    t := t || ' module';

    CASE action
        WHEN 'Read' THEN
            IF object_phrase IS NULL OR object_phrase = '' THEN
                RETURN 'Read ' || lower(trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'))) || ' data';
            ELSE
                RETURN 'Read ' || lower(object_phrase) || ' in ' || t;
            END IF;

        WHEN 'Write' THEN
            IF object_phrase IS NULL OR object_phrase = '' THEN
                RETURN 'Add/Update ' || lower(trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'))) || ' data';
            ELSE
                RETURN 'Add/Update ' || lower(object_phrase) || ' in ' || t;
            END IF;

        WHEN 'Delete' THEN
            IF object_phrase IS NULL OR object_phrase = '' THEN
                RETURN 'Delete general data';
            ELSE
                RETURN 'Delete ' || lower(object_phrase) || ' in ' || t;
            END IF;

        WHEN 'Approve' THEN
            IF object_phrase IS NULL OR object_phrase = '' THEN
                RETURN 'Approve ' || lower(trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'))) || ' actions';
            ELSE
                RETURN 'Approve ' || lower(object_phrase) || ' in the ' || t;
            END IF;

        WHEN 'Cancel' THEN
            RETURN 'Cancel ' || lower(COALESCE(object_phrase,'items')) || ' in ' || t;

        WHEN 'Reject' THEN
            RETURN 'Reject ' || lower(COALESCE(object_phrase,'items')) || ' in ' || t;

        WHEN 'Resolve' THEN
            RETURN 'Mark ' || lower(COALESCE(object_phrase,'items')) || ' as resolved in the ' || t;

        WHEN 'Assign' THEN
            RETURN 'Assign ' || lower(COALESCE(object_phrase,'items')) || ' in the ' || t;

        WHEN 'Copy' THEN
            RETURN 'Copy ' || lower(COALESCE(object_phrase,'items')) || ' in ' || t;

        WHEN 'Pay' THEN
            RETURN 'Make payments for ' || lower(COALESCE(object_phrase,'items'));

        WHEN 'SendForApproval' THEN
            RETURN 'Send ' || lower(COALESCE(object_phrase,'items')) || ' for approval';

        WHEN 'Import' THEN
            RETURN 'Import ' || lower(COALESCE(object_phrase,'items')) || ' data';

        ELSE
            -- Fallback
            IF object_phrase IS NULL OR object_phrase = '' THEN
                RETURN trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g')) || ' permission';
            ELSE
                RETURN trim(both ' ' FROM regexp_replace(module, '([a-z])([A-Z])', '\1 \2', 'g'))
                       || ' ' || trim(both ' ' FROM regexp_replace(object_phrase, '([a-z])([A-Z])', '\1 \2', 'g'))
                       || ' permission';
            END IF;
    END CASE;
END;
$function$

-- Function: get_account_expense_monthly_breakdown
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_account_expense_monthly_breakdown(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(account_id uuid, account_name text, year integer, apr numeric, apr_diff numeric, may numeric, may_diff numeric, jun numeric, jun_diff numeric, jul numeric, jul_diff numeric, aug numeric, aug_diff numeric, sep numeric, sep_diff numeric, oct numeric, oct_diff numeric, nov numeric, nov_diff numeric, "dec" numeric, dec_diff numeric, jan numeric, jan_diff numeric, feb numeric, feb_diff numeric, mar numeric, mar_diff numeric, total numeric, difference numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_organization_id UUID;
    v_start_date DATE;
    v_end_date DATE;
    v_prev_start_date DATE;
    v_prev_end_date DATE;
BEGIN
    -- Get organization and financial year details
    SELECT c.organization_id INTO v_organization_id FROM public.companies c WHERE c.id = p_company_id;
    SELECT fy.start_date, fy.end_date INTO v_start_date, v_end_date FROM public.finance_year fy WHERE fy.id = p_finance_year_id;
    SELECT pfy.start_date, pfy.end_date INTO v_prev_start_date, v_prev_end_date FROM public.finance_year pfy WHERE pfy.id = (p_finance_year_id - 1);
    
    RETURN QUERY 
    WITH expense_accounts AS (
        SELECT DISTINCT coa.id AS account_id, coa.name
        FROM chart_of_accounts coa
        JOIN account_types at ON coa.account_type_id = at.id
        WHERE at.id IN (SELECT id FROM get_account_type_hierarchy(5)) AND coa.organization_id = v_organization_id
    ),
    years AS (
        SELECT p_finance_year_id AS year UNION ALL SELECT p_finance_year_id - 1
    ),
    all_accounts AS (
        SELECT ea.account_id, ea.name, y.year
        FROM expense_accounts ea CROSS JOIN years y
    ),
    monthly_expenses AS (
        -- Get monthly totals, excluding opening balance entries
        SELECT 
            je.account_id,
            CASE 
                WHEN je.transaction_date BETWEEN v_start_date AND v_end_date THEN p_finance_year_id
                WHEN je.transaction_date BETWEEN v_prev_start_date AND v_prev_end_date THEN (p_finance_year_id - 1)
            END AS year,
            EXTRACT(MONTH FROM je.transaction_date) AS month,
            SUM(je.amount) AS amount
        FROM journal_entries je
        JOIN transaction_headers th ON je.transaction_id = th.id
        WHERE th.company_id = p_company_id
          AND je.transaction_date BETWEEN v_prev_start_date AND v_end_date
          AND th.transaction_source_type != 18
          AND th.is_deleted = FALSE
          AND je.is_deleted = FALSE
        GROUP BY je.account_id, year, EXTRACT(MONTH FROM je.transaction_date)
    ),
    pivoted_expenses AS (
        -- Pivot data to month-wise columns
        SELECT 
            aa.account_id, aa.name AS account_name, aa.year,
            COALESCE(SUM(CASE WHEN me.month = 4 THEN me.amount ELSE 0 END), 0) AS apr,
            COALESCE(SUM(CASE WHEN me.month = 5 THEN me.amount ELSE 0 END), 0) AS may,
            COALESCE(SUM(CASE WHEN me.month = 6 THEN me.amount ELSE 0 END), 0) AS jun,
            COALESCE(SUM(CASE WHEN me.month = 7 THEN me.amount ELSE 0 END), 0) AS jul,
            COALESCE(SUM(CASE WHEN me.month = 8 THEN me.amount ELSE 0 END), 0) AS aug,
            COALESCE(SUM(CASE WHEN me.month = 9 THEN me.amount ELSE 0 END), 0) AS sep,
            COALESCE(SUM(CASE WHEN me.month = 10 THEN me.amount ELSE 0 END), 0) AS oct,
            COALESCE(SUM(CASE WHEN me.month = 11 THEN me.amount ELSE 0 END), 0) AS nov,
            COALESCE(SUM(CASE WHEN me.month = 12 THEN me.amount ELSE 0 END), 0) AS "dec",
            COALESCE(SUM(CASE WHEN me.month = 1 THEN me.amount ELSE 0 END), 0) AS jan,
            COALESCE(SUM(CASE WHEN me.month = 2 THEN me.amount ELSE 0 END), 0) AS feb,
            COALESCE(SUM(CASE WHEN me.month = 3 THEN me.amount ELSE 0 END), 0) AS mar,
            COALESCE(SUM(me.amount), 0) AS total
        FROM all_accounts aa
        LEFT JOIN monthly_expenses me ON aa.account_id = me.account_id AND aa.year = me.year
        GROUP BY aa.account_id, aa.name, aa.year
    )
    -- Final table with difference calculation
    SELECT 
        pe.account_id, pe.account_name, pe.year,
        pe.apr, COALESCE(pe.apr - LAG(pe.apr) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS apr_diff,
        pe.may, COALESCE(pe.may - LAG(pe.may) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS may_diff,
        pe.jun, COALESCE(pe.jun - LAG(pe.jun) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS jun_diff,
        pe.jul, COALESCE(pe.jul - LAG(pe.jul) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS jul_diff,
        pe.aug, COALESCE(pe.aug - LAG(pe.aug) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS aug_diff,
        pe.sep, COALESCE(pe.sep - LAG(pe.sep) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS sep_diff,
        pe.oct, COALESCE(pe.oct - LAG(pe.oct) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS oct_diff,
        pe.nov, COALESCE(pe.nov - LAG(pe.nov) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS nov_diff,
        pe.dec, COALESCE(pe.dec - LAG(pe.dec) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS dec_diff,
        pe.jan, COALESCE(pe.jan - LAG(pe.jan) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS jan_diff,
        pe.feb, COALESCE(pe.feb - LAG(pe.feb) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS feb_diff,
        pe.mar, COALESCE(pe.mar - LAG(pe.mar) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS mar_diff,
        pe.total,
        COALESCE(pe.total - LAG(pe.total) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS difference
    FROM pivoted_expenses pe
    ORDER BY pe.account_name, pe.year;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_account_expense_monthly_breakdown(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(account_name text, year integer, apr numeric, apr_diff numeric, may numeric, may_diff numeric, jun numeric, jun_diff numeric, jul numeric, jul_diff numeric, aug numeric, aug_diff numeric, sep numeric, sep_diff numeric, oct numeric, oct_diff numeric, nov numeric, nov_diff numeric, "dec" numeric, dec_diff numeric, jan numeric, jan_diff numeric, feb numeric, feb_diff numeric, mar numeric, mar_diff numeric, total numeric, difference numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_organization_id UUID;
    v_start_date DATE;
    v_end_date DATE;
    v_prev_start_date DATE;
    v_prev_end_date DATE;
BEGIN
    -- Get the organization_id for the given company_id
    SELECT c.organization_id INTO v_organization_id 
    FROM public.companies c
    WHERE c.id = p_company_id;

    -- Get the start and end dates for the selected financial year
    SELECT fy.start_date, fy.end_date INTO v_start_date, v_end_date 
    FROM public.finance_year fy
    WHERE fy.id = p_finance_year_id;

    -- Get the start and end dates for the previous financial year
    SELECT pfy.start_date, pfy.end_date INTO v_prev_start_date, v_prev_end_date 
    FROM public.finance_year pfy
    WHERE pfy.id = (p_finance_year_id - 1);  

    RETURN QUERY 
    WITH expense_accounts AS (
        -- Fetch all expense accounts
        SELECT DISTINCT coa.id AS account_id, coa.name
        FROM chart_of_accounts coa
        JOIN account_types at ON coa.account_type_id = at.id
        WHERE at.id IN (SELECT id FROM get_account_type_hierarchy(5)) 
          AND coa.organization_id = v_organization_id
    ),
    years AS (
        -- Ensure two years are always present
        SELECT p_finance_year_id AS year
        UNION ALL
        SELECT p_finance_year_id - 1
    ),
    all_accounts AS (
        -- Ensure all accounts have both years
        SELECT ea.account_id, ea.name, y.year
        FROM expense_accounts ea
        CROSS JOIN years y
    ),
    monthly_expenses AS (
        -- Get monthly totals for the selected and previous financial years
        SELECT 
            je.account_id,
            CASE 
                WHEN je.transaction_date BETWEEN v_start_date AND v_end_date THEN p_finance_year_id
                WHEN je.transaction_date BETWEEN v_prev_start_date AND v_prev_end_date THEN (p_finance_year_id - 1)
            END AS year,
            EXTRACT(MONTH FROM je.transaction_date) AS month,
            SUM(je.amount) AS amount
        FROM journal_entries je
        JOIN transaction_headers th ON je.transaction_id = th.id
        WHERE th.company_id = p_company_id
        AND je.transaction_date BETWEEN v_prev_start_date AND v_end_date  
        GROUP BY je.account_id, year, EXTRACT(MONTH FROM je.transaction_date)
    ),
    pivoted_expenses AS (
        -- Pivoting data to month-wise columns
        SELECT 
            aa.name AS account_name,
            aa.year,
            COALESCE(SUM(CASE WHEN me.month = 4 THEN me.amount ELSE 0 END), 0) AS apr,
            COALESCE(SUM(CASE WHEN me.month = 5 THEN me.amount ELSE 0 END), 0) AS may,
            COALESCE(SUM(CASE WHEN me.month = 6 THEN me.amount ELSE 0 END), 0) AS jun,
            COALESCE(SUM(CASE WHEN me.month = 7 THEN me.amount ELSE 0 END), 0) AS jul,
            COALESCE(SUM(CASE WHEN me.month = 8 THEN me.amount ELSE 0 END), 0) AS aug,
            COALESCE(SUM(CASE WHEN me.month = 9 THEN me.amount ELSE 0 END), 0) AS sep,
            COALESCE(SUM(CASE WHEN me.month = 10 THEN me.amount ELSE 0 END), 0) AS oct,
            COALESCE(SUM(CASE WHEN me.month = 11 THEN me.amount ELSE 0 END), 0) AS nov,
            COALESCE(SUM(CASE WHEN me.month = 12 THEN me.amount ELSE 0 END), 0) AS "dec",
            COALESCE(SUM(CASE WHEN me.month = 1 THEN me.amount ELSE 0 END), 0) AS jan,
            COALESCE(SUM(CASE WHEN me.month = 2 THEN me.amount ELSE 0 END), 0) AS feb,
            COALESCE(SUM(CASE WHEN me.month = 3 THEN me.amount ELSE 0 END), 0) AS mar,
            COALESCE(SUM(me.amount), 0) AS total
        FROM all_accounts aa
        LEFT JOIN monthly_expenses me ON aa.account_id = me.account_id AND aa.year = me.year
        GROUP BY aa.account_id, aa.name, aa.year
    )
    -- Final table with the difference calculation
    SELECT 
        pe.account_name,
        pe.year,
        pe.apr, COALESCE(pe.apr - LAG(pe.apr) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS apr_diff,
        pe.may, COALESCE(pe.may - LAG(pe.may) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS may_diff,
        pe.jun, COALESCE(pe.jun - LAG(pe.jun) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS jun_diff,
        pe.jul, COALESCE(pe.jul - LAG(pe.jul) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS jul_diff,
        pe.aug, COALESCE(pe.aug - LAG(pe.aug) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS aug_diff,
        pe.sep, COALESCE(pe.sep - LAG(pe.sep) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS sep_diff,
        pe.oct, COALESCE(pe.oct - LAG(pe.oct) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS oct_diff,
        pe.nov, COALESCE(pe.nov - LAG(pe.nov) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS nov_diff,
        pe.dec, COALESCE(pe.dec - LAG(pe.dec) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS dec_diff,
        pe.jan, COALESCE(pe.jan - LAG(pe.jan) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS jan_diff,
        pe.feb, COALESCE(pe.feb - LAG(pe.feb) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS feb_diff,
        pe.mar, COALESCE(pe.mar - LAG(pe.mar) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS mar_diff,
        pe.total,
        COALESCE(pe.total - LAG(pe.total) OVER (PARTITION BY pe.account_name ORDER BY pe.year), 0) AS difference
    FROM pivoted_expenses pe
    ORDER BY pe.account_name, pe.year;
END;
$function$

-- Function: get_five_years_expenses
CREATE OR REPLACE FUNCTION public.get_five_years_expenses(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(id uuid, financial_year_range text, account_name text, y1_apr numeric, y1_may numeric, y1_jun numeric, y1_jul numeric, y1_aug numeric, y1_sep numeric, y1_oct numeric, y1_nov numeric, y1_dec numeric, y1_jan numeric, y1_feb numeric, y1_mar numeric, y2_apr numeric, y2_may numeric, y2_jun numeric, y2_jul numeric, y2_aug numeric, y2_sep numeric, y2_oct numeric, y2_nov numeric, y2_dec numeric, y2_jan numeric, y2_feb numeric, y2_mar numeric, y3_apr numeric, y3_may numeric, y3_jun numeric, y3_jul numeric, y3_aug numeric, y3_sep numeric, y3_oct numeric, y3_nov numeric, y3_dec numeric, y3_jan numeric, y3_feb numeric, y3_mar numeric, y4_apr numeric, y4_may numeric, y4_jun numeric, y4_jul numeric, y4_aug numeric, y4_sep numeric, y4_oct numeric, y4_nov numeric, y4_dec numeric, y4_jan numeric, y4_feb numeric, y4_mar numeric, y5_apr numeric, y5_may numeric, y5_jun numeric, y5_jul numeric, y5_aug numeric, y5_sep numeric, y5_oct numeric, y5_nov numeric, y5_dec numeric, y5_jan numeric, y5_feb numeric, y5_mar numeric)
 LANGUAGE plpgsql
 STABLE PARALLEL SAFE
AS $function$
DECLARE
    current_year_start DATE;
    current_year_end DATE;
    previous_year1_start DATE;
    previous_year1_end DATE;
    previous_year2_start DATE;
    previous_year2_end DATE;
    previous_year3_start DATE;
    previous_year3_end DATE;
    previous_year4_start DATE;
    previous_year4_end DATE;
    CONST_EXPENSE_TYPE_ID INTEGER := 5;
BEGIN
    -- Get start/end of current year
    SELECT fy.start_date, fy.end_date
    INTO current_year_start, current_year_end
    FROM public.finance_year fy
    WHERE fy.id = p_finance_year_id;

    IF current_year_start IS NULL OR current_year_end IS NULL THEN
        RAISE EXCEPTION 'Financial year with ID % not found', p_finance_year_id;
    END IF;

    -- Previous year 1
    SELECT fy.start_date, fy.end_date
    INTO previous_year1_start, previous_year1_end
    FROM public.finance_year fy
    WHERE fy.end_date < current_year_start
    ORDER BY fy.end_date DESC
    LIMIT 1;

    -- Previous year 2
    SELECT fy.start_date, fy.end_date
    INTO previous_year2_start, previous_year2_end
    FROM public.finance_year fy
    WHERE fy.end_date < previous_year1_start
    ORDER BY fy.end_date DESC
    LIMIT 1;

    -- Previous year 3
    SELECT fy.start_date, fy.end_date
    INTO previous_year3_start, previous_year3_end
    FROM public.finance_year fy
    WHERE fy.end_date < previous_year2_start
    ORDER BY fy.end_date DESC
    LIMIT 1;

    -- Previous year 4
    SELECT fy.start_date, fy.end_date
    INTO previous_year4_start, previous_year4_end
    FROM public.finance_year fy
    WHERE fy.end_date < previous_year3_start
    ORDER BY fy.end_date DESC
    LIMIT 1;

    RETURN QUERY
    WITH RECURSIVE AccountHierarchy AS (
        SELECT coa.id AS account_id, coa.name, coa.parent_account_id
        FROM public.chart_of_accounts coa
        WHERE coa.account_type_id = CONST_EXPENSE_TYPE_ID
        UNION ALL
        SELECT coa.id, coa.name, coa.parent_account_id
        FROM public.chart_of_accounts coa
        INNER JOIN AccountHierarchy ah ON coa.parent_account_id = ah.account_id
    ),
    MonthlyExpenses AS (
        SELECT 
            ah.name AS account_name,
            TO_CHAR(je.transaction_date, 'MM') AS transaction_month,
            CASE
                WHEN je.transaction_date BETWEEN previous_year4_start AND previous_year3_start - INTERVAL '1 day' THEN 'y1'
                WHEN je.transaction_date BETWEEN previous_year3_start AND previous_year2_start - INTERVAL '1 day' THEN 'y2'
                WHEN je.transaction_date BETWEEN previous_year2_start AND previous_year1_start - INTERVAL '1 day' THEN 'y3'
                WHEN je.transaction_date BETWEEN previous_year1_start AND current_year_start - INTERVAL '1 day' THEN 'y4'
                WHEN je.transaction_date BETWEEN current_year_start AND current_year_end THEN 'y5'
            END AS year_group,
            SUM(je.amount) AS monthly_amount
        FROM AccountHierarchy ah
        LEFT JOIN public.journal_entries je ON je.account_id = ah.account_id
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        WHERE th.company_id = p_company_id
          AND je.transaction_date BETWEEN previous_year4_start AND current_year_end
          AND je.is_deleted = FALSE
        GROUP BY ah.name, year_group, TO_CHAR(je.transaction_date, 'MM')
    ),
    AggregatedExpenses AS (
        SELECT 
            me.account_name,
            -- y1
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '04' THEN me.monthly_amount ELSE 0 END) AS y1_apr,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '05' THEN me.monthly_amount ELSE 0 END) AS y1_may,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '06' THEN me.monthly_amount ELSE 0 END) AS y1_jun,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '07' THEN me.monthly_amount ELSE 0 END) AS y1_jul,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '08' THEN me.monthly_amount ELSE 0 END) AS y1_aug,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '09' THEN me.monthly_amount ELSE 0 END) AS y1_sep,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '10' THEN me.monthly_amount ELSE 0 END) AS y1_oct,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '11' THEN me.monthly_amount ELSE 0 END) AS y1_nov,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '12' THEN me.monthly_amount ELSE 0 END) AS y1_dec,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '01' THEN me.monthly_amount ELSE 0 END) AS y1_jan,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '02' THEN me.monthly_amount ELSE 0 END) AS y1_feb,
            SUM(CASE WHEN me.year_group = 'y1' AND me.transaction_month = '03' THEN me.monthly_amount ELSE 0 END) AS y1_mar,
            -- y2
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '04' THEN me.monthly_amount ELSE 0 END) AS y2_apr,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '05' THEN me.monthly_amount ELSE 0 END) AS y2_may,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '06' THEN me.monthly_amount ELSE 0 END) AS y2_jun,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '07' THEN me.monthly_amount ELSE 0 END) AS y2_jul,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '08' THEN me.monthly_amount ELSE 0 END) AS y2_aug,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '09' THEN me.monthly_amount ELSE 0 END) AS y2_sep,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '10' THEN me.monthly_amount ELSE 0 END) AS y2_oct,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '11' THEN me.monthly_amount ELSE 0 END) AS y2_nov,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '12' THEN me.monthly_amount ELSE 0 END) AS y2_dec,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '01' THEN me.monthly_amount ELSE 0 END) AS y2_jan,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '02' THEN me.monthly_amount ELSE 0 END) AS y2_feb,
            SUM(CASE WHEN me.year_group = 'y2' AND me.transaction_month = '03' THEN me.monthly_amount ELSE 0 END) AS y2_mar,
            -- y3
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '04' THEN me.monthly_amount ELSE 0 END) AS y3_apr,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '05' THEN me.monthly_amount ELSE 0 END) AS y3_may,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '06' THEN me.monthly_amount ELSE 0 END) AS y3_jun,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '07' THEN me.monthly_amount ELSE 0 END) AS y3_jul,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '08' THEN me.monthly_amount ELSE 0 END) AS y3_aug,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '09' THEN me.monthly_amount ELSE 0 END) AS y3_sep,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '10' THEN me.monthly_amount ELSE 0 END) AS y3_oct,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '11' THEN me.monthly_amount ELSE 0 END) AS y3_nov,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '12' THEN me.monthly_amount ELSE 0 END) AS y3_dec,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '01' THEN me.monthly_amount ELSE 0 END) AS y3_jan,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '02' THEN me.monthly_amount ELSE 0 END) AS y3_feb,
            SUM(CASE WHEN me.year_group = 'y3' AND me.transaction_month = '03' THEN me.monthly_amount ELSE 0 END) AS y3_mar,
            -- y4
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '04' THEN me.monthly_amount ELSE 0 END) AS y4_apr,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '05' THEN me.monthly_amount ELSE 0 END) AS y4_may,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '06' THEN me.monthly_amount ELSE 0 END) AS y4_jun,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '07' THEN me.monthly_amount ELSE 0 END) AS y4_jul,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '08' THEN me.monthly_amount ELSE 0 END) AS y4_aug,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '09' THEN me.monthly_amount ELSE 0 END) AS y4_sep,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '10' THEN me.monthly_amount ELSE 0 END) AS y4_oct,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '11' THEN me.monthly_amount ELSE 0 END) AS y4_nov,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '12' THEN me.monthly_amount ELSE 0 END) AS y4_dec,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '01' THEN me.monthly_amount ELSE 0 END) AS y4_jan,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '02' THEN me.monthly_amount ELSE 0 END) AS y4_feb,
            SUM(CASE WHEN me.year_group = 'y4' AND me.transaction_month = '03' THEN me.monthly_amount ELSE 0 END) AS y4_mar,
            -- y5
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '04' THEN me.monthly_amount ELSE 0 END) AS y5_apr,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '05' THEN me.monthly_amount ELSE 0 END) AS y5_may,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '06' THEN me.monthly_amount ELSE 0 END) AS y5_jun,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '07' THEN me.monthly_amount ELSE 0 END) AS y5_jul,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '08' THEN me.monthly_amount ELSE 0 END) AS y5_aug,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '09' THEN me.monthly_amount ELSE 0 END) AS y5_sep,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '10' THEN me.monthly_amount ELSE 0 END) AS y5_oct,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '11' THEN me.monthly_amount ELSE 0 END) AS y5_nov,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '12' THEN me.monthly_amount ELSE 0 END) AS y5_dec,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '01' THEN me.monthly_amount ELSE 0 END) AS y5_jan,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '02' THEN me.monthly_amount ELSE 0 END) AS y5_feb,
            SUM(CASE WHEN me.year_group = 'y5' AND me.transaction_month = '03' THEN me.monthly_amount ELSE 0 END) AS y5_mar
        FROM MonthlyExpenses me
        GROUP BY me.account_name
    )
    SELECT
        gen_random_uuid() AS id,
        CONCAT(EXTRACT(YEAR FROM previous_year4_start), '-', EXTRACT(YEAR FROM current_year_end)) AS financial_year_range,
        ae.account_name,
        -- y1 months
        ae.y1_apr, ae.y1_may, ae.y1_jun, ae.y1_jul, ae.y1_aug, ae.y1_sep, ae.y1_oct, ae.y1_nov, ae.y1_dec, ae.y1_jan, ae.y1_feb, ae.y1_mar,
        -- y2 months
        ae.y2_apr, ae.y2_may, ae.y2_jun, ae.y2_jul, ae.y2_aug, ae.y2_sep, ae.y2_oct, ae.y2_nov, ae.y2_dec, ae.y2_jan, ae.y2_feb, ae.y2_mar,
        -- y3 months
        ae.y3_apr, ae.y3_may, ae.y3_jun, ae.y3_jul, ae.y3_aug, ae.y3_sep, ae.y3_oct, ae.y3_nov, ae.y3_dec, ae.y3_jan, ae.y3_feb, ae.y3_mar,
        -- y4 months
        ae.y4_apr, ae.y4_may, ae.y4_jun, ae.y4_jul, ae.y4_aug, ae.y4_sep, ae.y4_oct, ae.y4_nov, ae.y4_dec, ae.y4_jan, ae.y4_feb, ae.y4_mar,
        -- y5 months
        ae.y5_apr, ae.y5_may, ae.y5_jun, ae.y5_jul, ae.y5_aug, ae.y5_sep, ae.y5_oct, ae.y5_nov, ae.y5_dec, ae.y5_jan, ae.y5_feb, ae.y5_mar
    FROM AggregatedExpenses ae
    ORDER BY
        COALESCE(ae.y1_apr,0)+COALESCE(ae.y1_may,0)+COALESCE(ae.y1_jun,0)+COALESCE(ae.y1_jul,0)+COALESCE(ae.y1_aug,0)+COALESCE(ae.y1_sep,0)+COALESCE(ae.y1_oct,0)+COALESCE(ae.y1_nov,0)+COALESCE(ae.y1_dec,0)+COALESCE(ae.y1_jan,0)+COALESCE(ae.y1_feb,0)+COALESCE(ae.y1_mar,0)
        +COALESCE(ae.y2_apr,0)+COALESCE(ae.y2_may,0)+COALESCE(ae.y2_jun,0)+COALESCE(ae.y2_jul,0)+COALESCE(ae.y2_aug,0)+COALESCE(ae.y2_sep,0)+COALESCE(ae.y2_oct,0)+COALESCE(ae.y2_nov,0)+COALESCE(ae.y2_dec,0)+COALESCE(ae.y2_jan,0)+COALESCE(ae.y2_feb,0)+COALESCE(ae.y2_mar,0)
        +COALESCE(ae.y3_apr,0)+COALESCE(ae.y3_may,0)+COALESCE(ae.y3_jun,0)+COALESCE(ae.y3_jul,0)+COALESCE(ae.y3_aug,0)+COALESCE(ae.y3_sep,0)+COALESCE(ae.y3_oct,0)+COALESCE(ae.y3_nov,0)+COALESCE(ae.y3_dec,0)+COALESCE(ae.y3_jan,0)+COALESCE(ae.y3_feb,0)+COALESCE(ae.y3_mar,0)
        +COALESCE(ae.y4_apr,0)+COALESCE(ae.y4_may,0)+COALESCE(ae.y4_jun,0)+COALESCE(ae.y4_jul,0)+COALESCE(ae.y4_aug,0)+COALESCE(ae.y4_sep,0)+COALESCE(ae.y4_oct,0)+COALESCE(ae.y4_nov,0)+COALESCE(ae.y4_dec,0)+COALESCE(ae.y4_jan,0)+COALESCE(ae.y4_feb,0)+COALESCE(ae.y4_mar,0)
        +COALESCE(ae.y5_apr,0)+COALESCE(ae.y5_may,0)+COALESCE(ae.y5_jun,0)+COALESCE(ae.y5_jul,0)+COALESCE(ae.y5_aug,0)+COALESCE(ae.y5_sep,0)+COALESCE(ae.y5_oct,0)+COALESCE(ae.y5_nov,0)+COALESCE(ae.y5_dec,0)+COALESCE(ae.y5_jan,0)+COALESCE(ae.y5_feb,0)+COALESCE(ae.y5_mar,0) 
    DESC
    LIMIT 12;
END;
$function$

-- Function: get_bank_statements
CREATE OR REPLACE FUNCTION public.get_bank_statements(p_company_id uuid, p_finyear_id integer, p_date_from timestamp without time zone DEFAULT NULL::timestamp without time zone, p_date_to timestamp without time zone DEFAULT NULL::timestamp without time zone)
 RETURNS TABLE(id integer, company_id uuid, bank_id uuid, bank_name text, txn_date timestamp without time zone, cheque_number character varying, description text, value_date timestamp without time zone, branch_code character varying, debit_amount numeric, credit_amount numeric, balance numeric, has_reconciled boolean, created_by uuid, created_on_utc timestamp without time zone, modified_by uuid, modified_on_utc timestamp without time zone, deleted_on_utc timestamp without time zone, is_deleted boolean, rec_status_id integer, rec_status text, rec_confidence_score numeric, rec_strategy_name text, rec_matched_party_name text, rec_party_id uuid, rec_party_type text, rec_reviewed_by uuid, rec_reviewed_on_utc timestamp without time zone, rec_matched_amount numeric)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    SELECT 
        bs.id,
        bs.company_id,
        bs.bank_id,
        coa.name AS bank_name,
        bs.txn_date::timestamp,
        bs.cheque_number,
        bs.description,
        bs.value_date::timestamp,
        bs.branch_code,
        bs.debit_amount,
        bs.credit_amount,
        bs.balance,
        bs.has_reconciled,
        bs.created_by,
        bs.created_on_utc,
        bs.modified_by,
        bs.modified_on_utc,
        bs.deleted_on_utc,
        bs.is_deleted,

        -- ✅ Finalized Reconciliation Status
        COALESCE(br.reconciliation_status_id, 0) AS rec_status_id,
        
        -- Determine rec_status based on staging status and confidence score
        CASE 
            WHEN br.reconciliation_status_id IS NOT NULL THEN 
                COALESCE(rs.status::text, 'unmatched') 
            WHEN brs.confidence_score >= 70.99 THEN 
                'matched'  -- Auto-match based on high confidence score
            WHEN brs.status = 'pending' THEN 
                'pending'  -- Pending review status
            ELSE 
                'unmatched'
        END AS rec_status,

        -- Latest staging details (AI / manual reconciliation suggestion)
        COALESCE(brs.confidence_score, 0) AS rec_confidence_score,
        COALESCE(brs.strategy_name::text, 'No Match Found') AS rec_strategy_name,
        brs.matched_party_name::text AS rec_matched_party_name,
        brs.party_id AS rec_party_id,
        brs.party_type::text AS rec_party_type,
        brs.reviewed_by AS rec_reviewed_by,
        brs.reviewed_on_utc AS rec_reviewed_on_utc,
        COALESCE(brs.matched_amount, 0) AS rec_matched_amount

    FROM public.bank_statements bs
    INNER JOIN public.chart_of_accounts coa 
        ON coa.id = bs.bank_id
        AND coa.account_type_id = 9
        AND coa.is_deleted = FALSE
    INNER JOIN public.finance_year fy
        ON fy.id = p_finyear_id

    -- 🟢 Latest staging entry (AI / manual reconciliation suggestion)
    LEFT JOIN LATERAL (
        SELECT brs_inner.* 
        FROM public.bank_reconciliation_stagings brs_inner
        WHERE brs_inner.company_id = bs.company_id
          AND brs_inner.bank_statement_id = bs.id
          AND brs_inner.is_deleted = FALSE
        ORDER BY brs_inner.created_on_utc DESC
        LIMIT 1
    ) brs ON TRUE

    -- 🟢 Finalized reconciliations
    LEFT JOIN public.bank_reconciliations br
        ON br.bank_statement_id = bs.id
        AND br.company_id = bs.company_id

    -- 🟢 Status lookup
    LEFT JOIN public.reconciliation_statuses rs
        ON rs.id = br.reconciliation_status_id

    WHERE bs.company_id = p_company_id
      AND bs.txn_date BETWEEN fy.start_date AND fy.end_date
      AND (p_date_from IS NULL OR bs.txn_date >= p_date_from)
      AND (p_date_to IS NULL OR bs.txn_date <= p_date_to)
      AND bs.is_deleted = FALSE

    ORDER BY bs.txn_date, bs.id;
END;
$function$

-- Function: get_comparative_accounts_overview
CREATE OR REPLACE FUNCTION public.get_comparative_accounts_overview(p_company_id uuid, p_fin_year_id integer)
 RETURNS TABLE(account_id uuid, account_name text, parent_account_id uuid, hierarchy_path text[], order_sequence text, financial_year integer, apr numeric, may numeric, jun numeric, jul numeric, aug numeric, sep numeric, oct numeric, nov numeric, "dec" numeric, jan numeric, feb numeric, mar numeric, total_sum numeric, difference numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE 
    v_current_year_id INTEGER := p_fin_year_id;
    v_previous_year_id INTEGER;
    v_organization_id UUID;
BEGIN
    -- Get organization
    SELECT c.organization_id INTO v_organization_id
    FROM public.companies c
    WHERE c.id = p_company_id;

    -- Find previous financial year (based on start_date)
    SELECT fy.id
    INTO v_previous_year_id
    FROM finance_year fy
    WHERE fy.start_date < (
        SELECT start_date FROM finance_year WHERE id = v_current_year_id
    )
    ORDER BY fy.start_date DESC
    LIMIT 1;

    RETURN QUERY
    WITH RECURSIVE account_with_path AS (
        -- Root accounts
        SELECT
            coa.id,
            coa.name,
            coa.parent_account_id,
            ARRAY[coa.name]::text[] AS path,
            coa.account_number::text AS order_sequence
        FROM chart_of_accounts coa
        WHERE coa.organization_id = v_organization_id
          AND (coa.parent_account_id IS NULL OR coa.parent_account_id = '00000000-0000-0000-0000-000000000000')
          AND coa.is_deleted = FALSE

        UNION ALL

        -- Children
        SELECT
            c.id,
            c.name,
            c.parent_account_id,
            awp.path || c.name,
            awp.order_sequence || '.' || c.account_number::text
        FROM chart_of_accounts c
        JOIN account_with_path awp ON c.parent_account_id = awp.id
        WHERE c.organization_id = v_organization_id
          AND c.is_deleted = FALSE
    ),
    leaf_accounts AS (
        SELECT a.id
        FROM account_with_path a
        WHERE NOT EXISTS (
            SELECT 1 FROM chart_of_accounts c
            WHERE c.parent_account_id = a.id
              AND c.organization_id = v_organization_id
              AND c.is_deleted = FALSE
        )
    ),
    financial_years AS (
        SELECT id AS fin_year_id, start_date, end_date
        FROM finance_year
        WHERE id IN (v_current_year_id, v_previous_year_id)
    ),
    aggregated_data AS (
        SELECT
            awp.id,
            awp.name,
            awp.parent_account_id,
            awp.path AS hierarchy_path,
            awp.order_sequence,
            fy.fin_year_id,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 4 THEN je.amount END), 0) AS apr,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 5 THEN je.amount END), 0) AS may,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 6 THEN je.amount END), 0) AS jun,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 7 THEN je.amount END), 0) AS jul,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 8 THEN je.amount END), 0) AS aug,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 9 THEN je.amount END), 0) AS sep,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 10 THEN je.amount END), 0) AS oct,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 11 THEN je.amount END), 0) AS nov,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 12 THEN je.amount END), 0) AS "dec",
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 1 THEN je.amount END), 0) AS jan,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 2 THEN je.amount END), 0) AS feb,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 3 THEN je.amount END), 0) AS mar
        FROM account_with_path awp
        JOIN leaf_accounts la ON la.id = awp.id         -- ✅ only leaf accounts get financial years
        CROSS JOIN financial_years fy
        LEFT JOIN journal_entries je 
               ON je.account_id = awp.id
              AND je.transaction_date BETWEEN fy.start_date AND fy.end_date
        LEFT JOIN transaction_headers th 
               ON th.id = je.transaction_id 
              AND th.company_id = p_company_id
        WHERE (th.transaction_source_type IS NULL OR th.transaction_source_type != 18)
        GROUP BY awp.id, awp.name, awp.parent_account_id, awp.path, awp.order_sequence, fy.fin_year_id
    )
    SELECT
        a1.id AS account_id,
        a1.name AS account_name,
        a1.parent_account_id,
        a1.hierarchy_path,
        a1.order_sequence,
        a1.fin_year_id AS financial_year,
        a1.apr, a1.may, a1.jun, a1.jul, a1.aug, a1.sep, a1.oct, a1.nov, a1."dec",
        a1.jan, a1.feb, a1.mar,
        (COALESCE(a1.apr,0) + COALESCE(a1.may,0) + COALESCE(a1.jun,0) +
         COALESCE(a1.jul,0) + COALESCE(a1.aug,0) + COALESCE(a1.sep,0) +
         COALESCE(a1.oct,0) + COALESCE(a1.nov,0) + COALESCE(a1."dec",0) +
         COALESCE(a1.jan,0) + COALESCE(a1.feb,0) + COALESCE(a1.mar,0)) AS total_sum,
        ((COALESCE(a1.apr,0) + COALESCE(a1.may,0) + COALESCE(a1.jun,0) +
          COALESCE(a1.jul,0) + COALESCE(a1.aug,0) + COALESCE(a1.sep,0) +
          COALESCE(a1.oct,0) + COALESCE(a1.nov,0) + COALESCE(a1."dec",0) +
          COALESCE(a1.jan,0) + COALESCE(a1.feb,0) + COALESCE(a1.mar,0))
         -
         (COALESCE(a2.apr,0) + COALESCE(a2.may,0) + COALESCE(a2.jun,0) +
          COALESCE(a2.jul,0) + COALESCE(a2.aug,0) + COALESCE(a2.sep,0) +
          COALESCE(a2.oct,0) + COALESCE(a2.nov,0) + COALESCE(a2."dec",0) +
          COALESCE(a2.jan,0) + COALESCE(a2.feb,0) + COALESCE(a2.mar,0))
        ) AS difference
    FROM aggregated_data a1
    LEFT JOIN aggregated_data a2 
           ON a1.id = a2.id
          AND a1.fin_year_id = v_current_year_id
          AND a2.fin_year_id = v_previous_year_id
    ORDER BY a1.order_sequence, a1.fin_year_id;
END;
$function$

-- Function: get_expense_categorization
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_expense_categorization(p_company_id uuid, p_period_type integer, p_finance_id integer)
 RETURNS TABLE(period text, year numeric, account_id uuid, account_name text, total_expense numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_organization_id uuid;
    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
    CONST_YTD CONSTANT INTEGER := 5;
BEGIN
    -- Get financial year boundaries
    SELECT start_date, end_date INTO v_financial_year_start, v_financial_year_end
    FROM public.finance_year
    WHERE id = p_finance_id;

    -- Get organization_id for the given company_id
    SELECT organization_id INTO v_organization_id
    FROM public.companies
    WHERE id = p_company_id;

    IF v_financial_year_start IS NULL OR v_financial_year_end IS NULL THEN
        RAISE EXCEPTION 'Financial year with ID % not found', p_finance_id;
    END IF;
    IF v_organization_id IS NULL THEN
        RAISE EXCEPTION 'Company % not found or missing organization_id', p_company_id;
    END IF;

    IF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        WITH months AS (
            SELECT 
                TO_CHAR(m, 'Mon') AS period,
                EXTRACT(YEAR FROM m) AS year,
                EXTRACT(MONTH FROM m) AS month_num
            FROM generate_series(v_financial_year_start, v_financial_year_end, '1 month'::interval) AS m
        )
        SELECT 
            months.period,
            months.year,
            coa.id AS account_id,
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM months
        LEFT JOIN public.journal_entries je 
            ON EXTRACT(MONTH FROM je.transaction_date) = months.month_num
            AND EXTRACT(YEAR FROM je.transaction_date) = months.year
            AND je.is_deleted = FALSE
        INNER JOIN public.transaction_headers th 
            ON je.transaction_id = th.id
            AND th.company_id = p_company_id
        INNER JOIN public.chart_of_accounts coa 
            ON je.account_id = coa.id
            AND coa.organization_id = v_organization_id
            AND coa.is_deleted = FALSE
        WHERE coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D'
        GROUP BY months.year, months.month_num, months.period, coa.id, coa.name
        ORDER BY months.year, months.month_num, coa.name;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        RETURN QUERY
        WITH quarters AS (
            SELECT 'Q1' AS period, v_financial_year_start AS start_date, v_financial_year_start + interval '2 month' AS end_date
            UNION ALL
            SELECT 'Q2', v_financial_year_start + interval '3 month', v_financial_year_start + interval '5 month'
            UNION ALL
            SELECT 'Q3', v_financial_year_start + interval '6 month', v_financial_year_start + interval '8 month'
            UNION ALL
            SELECT 'Q4', v_financial_year_start + interval '9 month', v_financial_year_end
        )
        SELECT 
            quarters.period,
            EXTRACT(YEAR FROM quarters.start_date) AS year,
            coa.id AS account_id,
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM quarters
        LEFT JOIN public.journal_entries je 
            ON je.transaction_date BETWEEN quarters.start_date AND quarters.end_date
            AND je.is_deleted = FALSE
        INNER JOIN public.transaction_headers th 
            ON je.transaction_id = th.id
            AND th.company_id = p_company_id
        INNER JOIN public.chart_of_accounts coa 
            ON je.account_id = coa.id
            AND coa.organization_id = v_organization_id
            AND coa.is_deleted = FALSE
        WHERE coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D'
        GROUP BY quarters.period, year, coa.id, coa.name
        ORDER BY year, quarters.period, coa.name;

    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        WITH half_years AS (
            SELECT 'H1' AS period, v_financial_year_start AS start_date, v_financial_year_start + interval '5 month' AS end_date
            UNION ALL
            SELECT 'H2', v_financial_year_start + interval '6 month', v_financial_year_end
        )
        SELECT 
            half_years.period,
            EXTRACT(YEAR FROM half_years.start_date) AS year,
            coa.id AS account_id,
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM half_years
        LEFT JOIN public.journal_entries je 
            ON je.transaction_date BETWEEN half_years.start_date AND half_years.end_date
            AND je.is_deleted = FALSE
        INNER JOIN public.transaction_headers th 
            ON je.transaction_id = th.id
            AND th.company_id = p_company_id
        INNER JOIN public.chart_of_accounts coa 
            ON je.account_id = coa.id
            AND coa.organization_id = v_organization_id
            AND coa.is_deleted = FALSE
        WHERE coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D'
        GROUP BY half_years.period, year, coa.id, coa.name
        ORDER BY year, half_years.period, coa.name;

    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        SELECT 
            'Year' AS period,
            EXTRACT(YEAR FROM je.transaction_date) AS year,
            coa.id AS account_id,
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM public.journal_entries je
        INNER JOIN public.transaction_headers th 
            ON je.transaction_id = th.id
            AND th.company_id = p_company_id
        INNER JOIN public.chart_of_accounts coa 
            ON je.account_id = coa.id
            AND coa.organization_id = v_organization_id
            AND coa.is_deleted = FALSE
        WHERE coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D'
            AND je.is_deleted = FALSE
        GROUP BY year, coa.id, coa.name
        ORDER BY year, coa.name;

    ELSIF p_period_type = CONST_YTD THEN
        RETURN QUERY
        WITH ytd_fin_years AS (
            SELECT fy.start_date, fy.end_date
            FROM public.finance_year fy
            WHERE EXTRACT(YEAR FROM fy.start_date) BETWEEN EXTRACT(YEAR FROM CURRENT_DATE) - 4 AND EXTRACT(YEAR FROM CURRENT_DATE)
            ORDER BY fy.start_date DESC
            LIMIT 5
        )
        SELECT 
            'YTD' AS period,
            NULL::numeric AS year,
            coa.id AS account_id,
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM ytd_fin_years
        LEFT JOIN public.journal_entries je
            ON je.transaction_date BETWEEN ytd_fin_years.start_date AND LEAST(
                ytd_fin_years.end_date,
                CASE WHEN CURRENT_DATE BETWEEN ytd_fin_years.start_date AND ytd_fin_years.end_date
                    THEN CURRENT_DATE ELSE ytd_fin_years.end_date END
            )
            AND je.is_deleted = FALSE
        LEFT JOIN public.transaction_headers th ON je.transaction_id = th.id
            AND th.company_id = p_company_id
        LEFT JOIN public.chart_of_accounts coa ON je.account_id = coa.id
            AND coa.organization_id = v_organization_id
            AND coa.is_deleted = FALSE
        WHERE coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND (coa.name IS NULL OR coa.name NOT IN ('Rounding Gain'))
        GROUP BY coa.id, coa.name
        ORDER BY total_expense DESC;

    END IF;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_expense_categorization(p_company_id uuid, p_period_type integer, p_finance_id integer)
 RETURNS TABLE(period text, year numeric, account_id uuid, account_name text, total_expense numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_financial_year_start DATE;
    v_financial_year_end DATE;
BEGIN
    -- Step 1: Get financial year boundaries
    SELECT start_date, end_date INTO v_financial_year_start, v_financial_year_end
    FROM public.finance_year
    WHERE id = p_finance_id;

    -- Raise an exception if financial year is not found
    IF v_financial_year_start IS NULL OR v_financial_year_end IS NULL THEN
        RAISE EXCEPTION 'Financial year with ID % not found', p_finance_id;
    END IF;

    -- Step 2: Categorize expenses based on period type
    IF p_period_type = 1 THEN -- Monthly Categorization
    RETURN QUERY
    WITH months AS (
        SELECT 
            TO_CHAR(m, 'Mon') AS period, 
            EXTRACT(YEAR FROM m) AS year, 
            EXTRACT(MONTH FROM m) AS month_num
        FROM generate_series(v_financial_year_start, v_financial_year_end, '1 month'::interval) AS m
    )
    SELECT 
        months.period,
        months.year,
        coa.id AS account_id,  -- 🔹 Added missing account_id
        coa.name AS account_name,
        COALESCE(SUM(je.amount), 0) AS total_expense
    FROM months
    LEFT JOIN public.journal_entries je 
        ON EXTRACT(MONTH FROM je.transaction_date) = months.month_num
        AND EXTRACT(YEAR FROM je.transaction_date) = months.year
    INNER JOIN public.transaction_headers th 
        ON je.transaction_id = th.id 
        AND th.company_id = p_company_id
    INNER JOIN public.chart_of_accounts coa 
        ON je.account_id = coa.id
    WHERE 
        coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
        AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        AND je.entry_type = 'D'
        AND je.is_deleted = FALSE
    GROUP BY months.year, months.month_num, months.period, coa.id, coa.name  -- 🔹 Added `coa.id` to GROUP BY
    ORDER BY months.year, months.month_num, coa.name;


    ELSIF p_period_type = 2 THEN -- Quarterly Categorization
        RETURN QUERY
        WITH quarters AS (
            SELECT 'Q1' AS period, v_financial_year_start AS start_date, v_financial_year_start + interval '2 month' AS end_date
            UNION ALL
            SELECT 'Q2', v_financial_year_start + interval '3 month', v_financial_year_start + interval '5 month'
            UNION ALL
            SELECT 'Q3', v_financial_year_start + interval '6 month', v_financial_year_start + interval '8 month'
            UNION ALL
            SELECT 'Q4', v_financial_year_start + interval '9 month', v_financial_year_end
        )
        SELECT 
            quarters.period,
            EXTRACT(YEAR FROM quarters.start_date) AS year,
            coa.id AS account_id, -- Added account_id
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM quarters
        LEFT JOIN public.journal_entries je 
            ON je.transaction_date BETWEEN quarters.start_date AND quarters.end_date
        INNER JOIN public.transaction_headers th 
            ON je.transaction_id = th.id 
            AND th.company_id = p_company_id
        INNER JOIN public.chart_of_accounts coa 
            ON je.account_id = coa.id
        WHERE 
            coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D'
            AND je.is_deleted = FALSE
        GROUP BY quarters.period, year, coa.id, coa.name
        ORDER BY year, quarters.period, coa.name;

    ELSIF p_period_type = 3 THEN -- Half-Yearly Categorization
        RETURN QUERY
        WITH half_years AS (
            SELECT 'H1' AS period, v_financial_year_start AS start_date, v_financial_year_start + interval '5 month' AS end_date
            UNION ALL
            SELECT 'H2', v_financial_year_start + interval '6 month', v_financial_year_end
        )
        SELECT 
            half_years.period,
            EXTRACT(YEAR FROM half_years.start_date) AS year,
            coa.id AS account_id, -- Added account_id
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM half_years
        LEFT JOIN public.journal_entries je 
            ON je.transaction_date BETWEEN half_years.start_date AND half_years.end_date
        INNER JOIN public.transaction_headers th 
            ON je.transaction_id = th.id 
            AND th.company_id = p_company_id
        INNER JOIN public.chart_of_accounts coa 
            ON je.account_id = coa.id
        WHERE 
            coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D'
            AND je.is_deleted = FALSE
        GROUP BY half_years.period, year, coa.id, coa.name
        ORDER BY year, half_years.period, coa.name;

    ELSIF p_period_type = 4 THEN -- Yearly Categorization
        RETURN QUERY
        SELECT 
            'Year' AS period, 
            EXTRACT(YEAR FROM je.transaction_date) AS year,
            coa.id AS account_id, -- Added account_id
            coa.name AS account_name,
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM public.journal_entries je
        INNER JOIN public.transaction_headers th 
            ON je.transaction_id = th.id 
            AND th.company_id = p_company_id
        INNER JOIN public.chart_of_accounts coa 
            ON je.account_id = coa.id
        WHERE 
            coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D'
            AND je.is_deleted = FALSE
        GROUP BY year, coa.id, coa.name
        ORDER BY year, coa.name;

    END IF;
END;
$function$

-- Function: approve_visitor_for_unit
CREATE OR REPLACE FUNCTION public.approve_visitor_for_unit(p_visitor_log_id integer, p_unit_id integer, p_resident_user uuid, p_resident_id integer)
 RETURNS TABLE(visitor_log_id integer, unit_id integer, approver_resident_id integer, final_status_id integer)
 LANGUAGE plpgsql
AS $function$
DECLARE
    local_total_visits INT;
    local_approved_count INT;
    local_rejected_count INT;
    local_new_visitor_status INT;
BEGIN
    -- Step 1: Approve for this unit only
    UPDATE public.multi_unit_visits
    SET visitor_statuses = 2, -- Approved
        modified_on_utc = NOW(),
        modified_by = p_resident_user
    WHERE visitor_log_id = p_visitor_log_id
      AND unit_id = p_unit_id
      AND is_deleted = FALSE;

    IF NOT FOUND THEN
        -- No update happened (invalid visitor_log_id or unit_id)
        RETURN;
    END IF;

    -- Step 2: Recalculate parent visitor log status
    SELECT
        COUNT(*),
        COUNT(*) FILTER (WHERE muv.visitor_statuses = 2), -- Approved
        COUNT(*) FILTER (WHERE muv.visitor_statuses = 6)  -- Rejected
    INTO
        local_total_visits,
        local_approved_count,
        local_rejected_count
    FROM public.multi_unit_visits muv
    WHERE muv.visitor_log_id = p_visitor_log_id
      AND muv.is_deleted = FALSE;

    -- Step 3: Decide new parent status
    IF local_approved_count = local_total_visits AND local_total_visits > 0 THEN
        local_new_visitor_status := 2; -- All Approved
    ELSIF local_approved_count > 0 THEN
        local_new_visitor_status := 7; -- Partial Approved
    ELSIF local_rejected_count > 0 THEN
        local_new_visitor_status := 6; -- Rejected
    ELSE
        local_new_visitor_status := 1; -- Pending
    END IF;

    UPDATE public.visitor_logs
    SET visitor_status_id = local_new_visitor_status,
        modified_on_utc = NOW(),
        modified_by = p_resident_user
    WHERE id = p_visitor_log_id;

    -- Step 4: Return minimal information for the service layer
    RETURN QUERY
    SELECT 
        p_visitor_log_id,
        p_unit_id,
        p_resident_id,         -- approver resident
        local_new_visitor_status;

END;
$function$

-- Function: pgp_pub_encrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_pub_encrypt_bytea(bytea, bytea, text)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_encrypt_bytea$function$

-- Function: pgp_pub_decrypt
CREATE OR REPLACE FUNCTION public.pgp_pub_decrypt(bytea, bytea)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_decrypt_text$function$

-- Function: pgp_pub_decrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_pub_decrypt_bytea(bytea, bytea)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_pub_decrypt_bytea$function$

-- Function: get_balance_sheet
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_balance_sheet(p_company_id uuid, p_finance_year_id integer, p_as_on_date date, p_is_get_all_for_organizations boolean)
 RETURNS TABLE(account_id uuid, account_type text, account_name text, amount numeric, category text)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_start_date DATE;
    v_end_date DATE;
    v_company_ids UUID[];
    v_organization_id UUID;
    asset_account_ids integer[];
    liability_account_ids integer[];
    equity_account_ids integer[];
BEGIN
    -- Fetch financial year start and end dates
    SELECT fy.start_date, fy.end_date
    INTO v_start_date, v_end_date
    FROM public.finance_year fy
    WHERE fy.id = p_finance_year_id;

    -- Cap the end date by the given as_on_date
    v_end_date := LEAST(v_end_date, p_as_on_date);

    -- Get organization id of company
    SELECT c.organization_id INTO v_organization_id
    FROM public.companies c
    WHERE c.id = p_company_id;

    -- Get account type hierarchies
    asset_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(1)); -- Assets
    liability_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(2)); -- Liabilities
    equity_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(3)); -- Equity

    -- Company IDs based on flag
    IF p_is_get_all_for_organizations THEN
        SELECT ARRAY_AGG(id)
        INTO v_company_ids
        FROM public.companies
        WHERE organization_id = v_organization_id;
    ELSE
        v_company_ids := ARRAY[p_company_id];
    END IF;

    -- Assets
    RETURN QUERY
    SELECT
        coa.id,
        at.name,
        coa.name,
        COALESCE(SUM(
            CASE 
                WHEN je.entry_type = 'D' THEN je.amount
                WHEN je.entry_type = 'C' THEN -je.amount
                ELSE 0
            END
        ),0) AS amount,
        'Assets'
    FROM public.chart_of_accounts coa
    JOIN public.account_types at ON coa.account_type_id = at.id
    JOIN public.journal_entries je ON je.account_id = coa.id
    JOIN public.transaction_headers th ON th.id = je.transaction_id
    WHERE th.company_id = ANY(v_company_ids)
      AND th.transaction_date BETWEEN v_start_date AND v_end_date
      AND NOT th.is_deleted
      AND NOT je.is_deleted
      AND coa.account_type_id = ANY(asset_account_ids)
    GROUP BY coa.id, at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;

    -- Liabilities
    RETURN QUERY
    SELECT
        coa.id,
        at.name,
        coa.name,
        COALESCE(SUM(
            CASE 
                WHEN je.entry_type = 'C' THEN je.amount
                WHEN je.entry_type = 'D' THEN -je.amount
                ELSE 0
            END
        ),0) AS amount,
        'Liabilities'
    FROM public.chart_of_accounts coa
    JOIN public.account_types at ON coa.account_type_id = at.id
    JOIN public.journal_entries je ON je.account_id = coa.id
    JOIN public.transaction_headers th ON th.id = je.transaction_id
    WHERE th.company_id = ANY(v_company_ids)
      AND th.transaction_date BETWEEN v_start_date AND v_end_date
      AND NOT th.is_deleted
      AND NOT je.is_deleted
      AND coa.account_type_id = ANY(liability_account_ids)
    GROUP BY coa.id, at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;

    -- Equity
    RETURN QUERY
    SELECT
        coa.id,
        at.name,
        coa.name,
        COALESCE(SUM(
            CASE 
                WHEN je.entry_type = 'C' THEN je.amount
                WHEN je.entry_type = 'D' THEN -je.amount
                ELSE 0
            END
        ),0) AS amount,
        'Equity'
    FROM public.chart_of_accounts coa
    JOIN public.account_types at ON coa.account_type_id = at.id
    JOIN public.journal_entries je ON je.account_id = coa.id
    JOIN public.transaction_headers th ON th.id = je.transaction_id
    WHERE th.company_id = ANY(v_company_ids)
      AND th.transaction_date BETWEEN v_start_date AND v_end_date
      AND NOT th.is_deleted
      AND NOT je.is_deleted
      AND coa.account_type_id = ANY(equity_account_ids)
    GROUP BY coa.id, at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;

END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_balance_sheet(p_company_id uuid, p_finance_year_id integer, p_as_on_date date, p_is_get_all_for_organizations boolean)
 RETURNS TABLE(account_type text, account_name text, amount numeric, category text)
 LANGUAGE plpgsql
AS $function$

DECLARE
    v_start_date DATE;
    v_end_date DATE;
    v_company_ids UUID[];
    v_organization_id UUID;
    asset_account_ids integer[];
    liability_account_ids integer[];
    equity_account_ids integer[];
BEGIN
    -- Fetch financial year start and end dates
    SELECT fy.start_date, fy.end_date
    INTO v_start_date, v_end_date
    FROM public.finance_year fy
    WHERE fy.id = p_finance_year_id;

    -- Cap the end date by the given as_on_date
    v_end_date := LEAST(v_end_date, p_as_on_date);

    -- Get organization id of company
    SELECT c.organization_id INTO v_organization_id
    FROM public.companies c
    WHERE c.id = p_company_id;

    -- Get account type hierarchies for assets, liabilities, and equity
    asset_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(1)); -- Assets
    liability_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(2)); -- Liabilities
    equity_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(3)); -- Equity

    -- Determine company IDs based on flag
    IF p_is_get_all_for_organizations THEN
        SELECT ARRAY_AGG(id)
        INTO v_company_ids
        FROM public.companies
        WHERE organization_id = v_organization_id;
    ELSE
        v_company_ids := ARRAY[p_company_id];
    END IF;

    -- Return Assets
    RETURN QUERY
    SELECT
        at.name AS account_type,
        coa.name AS account_name,
        COALESCE(
            SUM(
                CASE 
                    WHEN ob.entry_type = 'D' THEN ob.balance
                    ELSE -ob.balance                        
                END
            ), 0) +
        COALESCE(
            SUM(CASE 
                WHEN je.entry_type = 'D' THEN je.amount  -- Debit increases asset balance
                WHEN je.entry_type = 'C' THEN -je.amount -- Credit decreases asset balance
                ELSE 0 
            END), 0
        ) AS amount,
        'Assets' AS category
    FROM public.chart_of_accounts coa
    LEFT JOIN public.journal_entries je ON je.account_id = coa.id
    LEFT JOIN public.transaction_headers th ON je.transaction_id = th.id
    LEFT JOIN public.opening_balances ob ON ob.account_id = coa.id
        AND ob.organization_id = v_organization_id
        AND ob.finyear_id = p_finance_year_id
        AND ob.is_deleted = FALSE
    INNER JOIN public.account_types at ON coa.account_type_id = at.id
    WHERE th.company_id = ANY(v_company_ids)
        AND th.transaction_date BETWEEN v_start_date AND v_end_date
        AND NOT th.is_deleted
        AND NOT je.is_deleted
        AND coa.account_type_id = ANY(asset_account_ids)
    GROUP BY at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;

    -- Return Liabilities
    RETURN QUERY
    SELECT
        at.name AS account_type,
        coa.name AS account_name,
        COALESCE(
            SUM(
                CASE 
                    WHEN ob.entry_type = 'C' THEN ob.balance  
                    ELSE -ob.balance                        
                END
            ), 0) +
        COALESCE(
            SUM(CASE 
                WHEN je.entry_type = 'C' THEN je.amount 
                WHEN je.entry_type = 'D' THEN -je.amount
                ELSE 0 
            END), 0
        ) AS amount,
        'Liabilities' AS category
    FROM public.chart_of_accounts coa
    LEFT JOIN public.journal_entries je ON je.account_id = coa.id
    LEFT JOIN public.transaction_headers th ON je.transaction_id = th.id
    LEFT JOIN public.opening_balances ob ON ob.account_id = coa.id
        AND ob.organization_id = v_organization_id
        AND ob.finyear_id = p_finance_year_id
        AND ob.is_deleted = FALSE
    INNER JOIN public.account_types at ON coa.account_type_id = at.id
    WHERE th.company_id = ANY(v_company_ids)
        AND th.transaction_date BETWEEN v_start_date AND v_end_date
        AND NOT th.is_deleted
        AND NOT je.is_deleted
        AND coa.account_type_id = ANY(liability_account_ids)
    GROUP BY at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;

    -- Return Equity
    RETURN QUERY
    SELECT
        at.name AS account_type,
        coa.name AS account_name,
        COALESCE(
            SUM(
                CASE 
                    WHEN ob.entry_type = 'C' THEN ob.balance
                    ELSE -ob.balance                        
                END
            ), 0) +
        COALESCE(
            SUM(CASE 
                WHEN je.entry_type = 'C' THEN je.amount
                WHEN je.entry_type = 'D' THEN -je.amount
                ELSE 0 
            END), 0
        ) AS amount,
        'Equity' AS category
    FROM public.chart_of_accounts coa
    LEFT JOIN public.journal_entries je ON je.account_id = coa.id
    LEFT JOIN public.transaction_headers th ON je.transaction_id = th.id
    LEFT JOIN public.opening_balances ob ON ob.account_id = coa.id
        AND ob.organization_id = v_organization_id
        AND ob.finyear_id = p_finance_year_id
        AND ob.is_deleted = FALSE
    INNER JOIN public.account_types at ON coa.account_type_id = at.id
    WHERE th.company_id = ANY(v_company_ids)
        AND th.transaction_date BETWEEN v_start_date AND v_end_date
        AND NOT th.is_deleted
        AND NOT je.is_deleted
        AND coa.account_type_id = ANY(equity_account_ids)
    GROUP BY at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;

END;
$function$

-- Function: grant_full_schema_access
CREATE OR REPLACE FUNCTION public.grant_full_schema_access(p_schema text, p_user text)
 RETURNS void
 LANGUAGE plpgsql
AS $function$
DECLARE
    obj RECORD;
BEGIN
    -- Grant on tables
    FOR obj IN
        SELECT table_name
        FROM information_schema.tables
        WHERE table_schema = p_schema
          AND table_type = 'BASE TABLE'
    LOOP
        EXECUTE format('GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE %I.%I TO %I;', p_schema, obj.table_name, p_user);
        RAISE NOTICE 'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE %.% TO %;', p_schema, obj.table_name, p_user;
    END LOOP;

    -- Grant on sequences (USAGE + SELECT + UPDATE: full coverage)
    FOR obj IN
        SELECT c.relname AS sequence_name
        FROM pg_class c
        JOIN pg_namespace n ON n.oid = c.relnamespace
        WHERE c.relkind = 'S'
          AND n.nspname = p_schema
    LOOP
        EXECUTE format('GRANT USAGE, SELECT, UPDATE ON SEQUENCE %I.%I TO %I;', p_schema, obj.sequence_name, p_user);
        RAISE NOTICE 'GRANT USAGE, SELECT, UPDATE ON SEQUENCE %.% TO %;', p_schema, obj.sequence_name, p_user;
    END LOOP;

    -- Grant on all functions (handles all argument types)
    FOR obj IN
        SELECT
            p.proname AS function_name,
            pg_get_function_identity_arguments(p.oid) AS args
        FROM
            pg_proc p
            JOIN pg_namespace n ON p.pronamespace = n.oid
        WHERE
            n.nspname = p_schema
            AND p.prokind = 'f' -- f = function
    LOOP
        EXECUTE format(
            'GRANT EXECUTE ON FUNCTION %I.%I(%s) TO %I;',
            p_schema, obj.function_name, obj.args, p_user
        );
        RAISE NOTICE 'GRANT EXECUTE ON FUNCTION %.%(%) TO %;', p_schema, obj.function_name, obj.args, p_user;
    END LOOP;

    -- Grant on all procedures (Postgres 11+)
    FOR obj IN
        SELECT
            p.proname AS procedure_name,
            pg_get_function_identity_arguments(p.oid) AS args
        FROM
            pg_proc p
            JOIN pg_namespace n ON p.pronamespace = n.oid
        WHERE
            n.nspname = p_schema
            AND p.prokind = 'p' -- p = procedure
    LOOP
        EXECUTE format(
            'GRANT EXECUTE ON PROCEDURE %I.%I(%s) TO %I;',
            p_schema, obj.procedure_name, obj.args, p_user
        );
        RAISE NOTICE 'GRANT EXECUTE ON PROCEDURE %.%(%) TO %;', p_schema, obj.procedure_name, obj.args, p_user;
    END LOOP;

END;
$function$

-- Function: dummy_hello_function
CREATE OR REPLACE FUNCTION public.dummy_hello_function(name text)
 RETURNS text
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN 'Hello, ' || name || '!';
END;
$function$

-- Function: get_all_users
CREATE OR REPLACE FUNCTION public.get_all_users()
 RETURNS TABLE(id uuid, first_name character varying, last_name character varying, email character varying, phone_number character varying, user_name text)
 LANGUAGE sql
AS $function$
    SELECT id, first_name, last_name, email, phone_number, user_name
    FROM public.users;
$function$

-- Function: get_income_expense_overview
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_income_expense_overview(p_company_id uuid, p_period_type integer, p_finance_id integer)
 RETURNS TABLE(period text, year numeric, total_income numeric, total_expense numeric, actual_income numeric, actual_expense numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_finance_year_start NUMERIC;
    v_finance_year_end NUMERIC;

    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
    CONST_YTD CONSTANT INTEGER := 5;
BEGIN
    IF p_period_type != CONST_YTD THEN
        SELECT start_date, end_date,
               EXTRACT(YEAR FROM start_date),
               EXTRACT(YEAR FROM end_date)
        INTO v_financial_year_start, v_financial_year_end,
             v_finance_year_start, v_finance_year_end
        FROM public.finance_year
        WHERE id = p_finance_id;
    END IF;

    IF p_period_type = CONST_YTD THEN
        -- Returns last 5 years, fiscal quarters (Apr–Jun, Jul–Sep, Oct–Dec, Jan–Mar)
       RETURN QUERY
    WITH recent_years AS (
        SELECT fy.id, fy.start_date, fy.end_date,
               EXTRACT(YEAR FROM fy.start_date) AS fiscal_year
        FROM public.finance_year fy
        WHERE EXTRACT(YEAR FROM fy.start_date) >= EXTRACT(YEAR FROM CURRENT_DATE) - 4
          AND EXTRACT(YEAR FROM fy.start_date) <= EXTRACT(YEAR FROM CURRENT_DATE)
        ORDER BY fy.start_date DESC
        LIMIT 5
    ),
    quarters AS (
        SELECT id AS finance_id, fiscal_year, 'Q1' AS period,
               make_date(fiscal_year::int, 4, 1) AS period_start,
               make_date(fiscal_year::int, 6, 30) AS period_end
          FROM recent_years
        UNION ALL
        SELECT id, fiscal_year, 'Q2',
               make_date(fiscal_year::int, 7, 1),
               make_date(fiscal_year::int, 9, 30)
          FROM recent_years
        UNION ALL
        SELECT id, fiscal_year, 'Q3',
               make_date(fiscal_year::int, 10, 1),
               make_date(fiscal_year::int, 12, 31)
          FROM recent_years
        UNION ALL
        -- For Q4, fiscal_year stays the same, but period_start/period_end move to the next calendar year
        SELECT id, fiscal_year, 'Q4',
               make_date((fiscal_year::int) + 1, 1, 1),
               make_date((fiscal_year::int) + 1, 3, 31)
          FROM recent_years
    ),
    filtered_je AS (
        SELECT
            je.amount,
            je.entry_type,
            tr.company_id,
            je.transaction_date,
            coa.account_type_id
        FROM journal_entries je
        JOIN transaction_headers tr ON je.transaction_id = tr.id
        JOIN chart_of_accounts coa ON je.account_id = coa.id
        WHERE je.is_deleted = FALSE
          AND tr.company_id = p_company_id
    )
    SELECT
        CONCAT(q.period, ' ', q.fiscal_year) AS period,
        q.fiscal_year,
        COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS total_income,
        COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,
        COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,
        COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                         AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense
    FROM quarters q
    LEFT JOIN filtered_je je
        ON je.transaction_date BETWEEN q.period_start AND q.period_end
    GROUP BY q.period, q.fiscal_year
    HAVING
        SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
     OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
     OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
     OR SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                 AND je.transaction_date BETWEEN q.period_start AND q.period_end THEN je.amount ELSE 0 END) > 0
    ORDER BY q.fiscal_year, q.period;

    ELSIF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        WITH months AS (
            SELECT
                generate_series::date AS month_start,
                (generate_series + interval '1 month')::date AS month_end
            FROM generate_series(
                v_financial_year_start,
                v_financial_year_end,
                interval '1 month'
            )
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            to_char(m.month_start, 'Mon YYYY') AS period,
            EXTRACT(YEAR FROM m.month_start) AS year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                              AND je.transaction_date >= m.month_start AND je.transaction_date < m.month_end THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM months m
        LEFT JOIN filtered_je je
            ON je.transaction_date >= m.month_start AND je.transaction_date < m.month_end
        GROUP BY m.month_start
        ORDER BY m.month_start;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        -- Single year, use explicit fiscal quarters
        RETURN QUERY
        WITH fiscal_quarters AS (
            SELECT 'Q1' AS period, v_financial_year_start AS period_start, make_date(v_finance_year_start::int, 6, 30) AS period_end, v_finance_year_start AS year
            UNION ALL
            SELECT 'Q2', make_date(v_finance_year_start::int, 7, 1), make_date(v_finance_year_start::int, 9, 30), v_finance_year_start
            UNION ALL
            SELECT 'Q3', make_date(v_finance_year_start::int, 10, 1), make_date(v_finance_year_start::int, 12, 31), v_finance_year_start
            UNION ALL
            SELECT 'Q4', make_date((v_finance_year_start::int) + 1, 1, 1), v_financial_year_end, v_finance_year_start
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(fq.period, ' ', fq.year) AS period,
            fq.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN fq.period_start AND fq.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM fiscal_quarters fq
        LEFT JOIN filtered_je je
            ON je.transaction_date BETWEEN fq.period_start AND fq.period_end
        GROUP BY fq.period, fq.year
        ORDER BY fq.year, fq.period;

    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        WITH half_years AS (
            SELECT 'H1' AS period, v_financial_year_start AS period_start, make_date(v_finance_year_start::int, 9, 30) AS period_end, v_finance_year_start AS year
            UNION ALL
            SELECT 'H2', make_date(v_finance_year_start::int, 10, 1), v_financial_year_end, v_finance_year_start
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(h.period, ' ', h.year) AS period,
            h.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                              AND je.transaction_date BETWEEN h.period_start AND h.period_end THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM half_years h
        JOIN filtered_je je
            ON je.transaction_date BETWEEN h.period_start AND h.period_end
        GROUP BY h.period, h.year
        ORDER BY h.year, h.period;

    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        WITH filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                je.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT('Year ', v_finance_year_start) AS period,
            v_finance_year_start AS year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0) AS total_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0) AS total_expense,
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0) AS actual_income,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0) AS actual_expense
        FROM filtered_je je;

    ELSE
        RAISE EXCEPTION 'Unsupported period type %', p_period_type;
    END IF;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_income_expense_overview(p_company_id uuid, p_period_type integer, p_finance_id integer)
 RETURNS TABLE(period text, year numeric, total_income numeric, total_expense numeric, actual_income numeric, actual_expense numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_financial_year_start date;
    v_financial_year_end date;
    v_finance_year_start numeric;
    v_finance_year_end numeric;

    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
    CONST_YTD CONSTANT INTEGER := 5;
BEGIN
    IF p_period_type != CONST_YTD THEN
        SELECT start_date, end_date,
               EXTRACT(YEAR FROM start_date),
               EXTRACT(YEAR FROM end_date)
        INTO v_financial_year_start, v_financial_year_end,
             v_finance_year_start, v_finance_year_end
        FROM public.finance_year
        WHERE id = p_finance_id;
    END IF;

    IF p_period_type = CONST_YTD THEN
        RETURN QUERY
        WITH recent_years AS (
            SELECT fy.id, fy.start_date, fy.end_date,
                   EXTRACT(YEAR FROM fy.start_date) AS year_start,
                   EXTRACT(YEAR FROM fy.end_date) AS year_end
            FROM finance_year fy
            WHERE EXTRACT(YEAR FROM fy.start_date) >= EXTRACT(YEAR FROM CURRENT_DATE) - 4
              AND EXTRACT(YEAR FROM fy.start_date) <= EXTRACT(YEAR FROM CURRENT_DATE)
            ORDER BY fy.start_date DESC
            LIMIT 5
        ),
        ytd_periods AS (
            SELECT id AS finance_id, 'YTD H1' AS period,
                   (start_date + INTERVAL '5 months 29 days')::date AS period_end,
                   EXTRACT(YEAR FROM start_date) AS year,
                   start_date AS fy_start
            FROM recent_years
            UNION ALL
            SELECT id, 'YTD H2', end_date,
                   EXTRACT(YEAR FROM end_date) AS year,
                   start_date
            FROM recent_years
            WHERE end_date <= CURRENT_DATE
              AND CURRENT_DATE >= (start_date + INTERVAL '6 months') -- skip if it's a future YTD H2
        ),
        filtered_je AS (
            SELECT
                je.amount,
                je.entry_type,
                tr.company_id,
                tr.transaction_date,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE je.is_deleted = FALSE
        )
        SELECT
            CONCAT(yp.period, ' ', yp.year) AS period,
            yp.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                             AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END), 0)
        FROM ytd_periods yp
        LEFT JOIN filtered_je je ON je.company_id = p_company_id
        GROUP BY yp.period, yp.year, yp.period_end
        HAVING
            SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
         OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
         OR SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
         OR SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9)
                     AND je.transaction_date BETWEEN yp.fy_start AND yp.period_end THEN je.amount ELSE 0 END) > 0
        ORDER BY yp.year, yp.period;

    ELSIF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        WITH months AS (
            SELECT
                generate_series::date AS month_start,
                (generate_series + interval '1 month')::date AS month_end
            FROM generate_series(
                v_financial_year_start,
                v_financial_year_end,
                interval '1 month'
            )
        ),
        filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            to_char(m.month_start, 'Mon YYYY') AS period,
            EXTRACT(YEAR FROM m.month_start) AS year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM months m
        LEFT JOIN filtered_je je ON je.transaction_date >= m.month_start AND je.transaction_date < m.month_end
        GROUP BY m.month_start
        ORDER BY m.month_start;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        RETURN QUERY
        WITH quarters AS (
            SELECT 'Q1' AS period, 4 AS start_month, 6 AS end_month, v_finance_year_start AS year
            UNION ALL SELECT 'Q2', 7, 9, v_finance_year_start
            UNION ALL SELECT 'Q3', 10, 12, v_finance_year_start
            UNION ALL SELECT 'Q4', 1, 3, v_finance_year_end
        ),
        filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(q.period, ' ', q.year),
            q.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM quarters q
        JOIN filtered_je je ON EXTRACT(MONTH FROM je.transaction_date) BETWEEN q.start_month AND q.end_month
                             AND EXTRACT(YEAR FROM je.transaction_date) = q.year
        GROUP BY q.period, q.year
        ORDER BY q.year, q.period;

    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        WITH half_years AS (
            SELECT 'H1' AS period, 4 AS start_month, 9 AS end_month, v_finance_year_start AS year
            UNION ALL SELECT 'H2', 10, 12, v_finance_year_start
            UNION ALL SELECT 'H2', 1, 3, v_finance_year_end
        ),
        filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT(h.period, ' ', h.year),
            h.year,
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM half_years h
        JOIN filtered_je je ON EXTRACT(MONTH FROM je.transaction_date) BETWEEN h.start_month AND h.end_month
                             AND EXTRACT(YEAR FROM je.transaction_date) = h.year
        GROUP BY h.period, h.year
        ORDER BY h.year, h.period;

    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        WITH filtered_je AS (
            SELECT
                je.*,
                coa.account_type_id
            FROM journal_entries je
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            JOIN chart_of_accounts coa ON je.account_id = coa.id
            WHERE tr.company_id = p_company_id
              AND je.is_deleted = FALSE
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        )
        SELECT
            CONCAT('Year ', EXTRACT(YEAR FROM je.transaction_date)),
            EXTRACT(YEAR FROM je.transaction_date),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (4,14,15,19,20) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (5,16,17,18,21,22) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0),
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' AND je.account_type_id IN (8,9) THEN je.amount ELSE 0 END), 0)
        FROM filtered_je je
        GROUP BY EXTRACT(YEAR FROM je.transaction_date)
        ORDER BY EXTRACT(YEAR FROM je.transaction_date);

    ELSE
        RAISE EXCEPTION 'Unsupported period type %', p_period_type;
    END IF;
END;
$function$

-- Function: get_vendor_opening_balance
CREATE OR REPLACE FUNCTION public.get_vendor_opening_balance(p_vendor_id uuid, p_finyear_id integer)
 RETURNS TABLE(transaction_date timestamp without time zone, vendor_id uuid, vendor_name text, description text, credit numeric, debit numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_year_text text;
BEGIN
    -- Fetch the year text for the given finance year id
    SELECT year INTO v_year_text FROM public.finance_year WHERE id = p_finyear_id;
    IF v_year_text IS NULL THEN
        RAISE EXCEPTION 'Finance year with id % not found!', p_finyear_id;
    END IF;

    RETURN QUERY
    SELECT
        th.transaction_date,
        th.vendor_id,
        v.name::text AS vendor_name,  -- Explicit cast to match function signature
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) AS credit,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) AS debit
    FROM public.transaction_headers th
    JOIN public.vendors v ON th.vendor_id = v.id
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts sc ON sc.name ILIKE '%Sundry Creditors%'
    WHERE th.vendor_id = p_vendor_id
      AND je.account_id = sc.id
      AND th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'
    ORDER BY th.transaction_date;
END;
$function$

-- Function: get_customer_ledger
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_customer_ledger(p_company_id uuid, p_organization_id uuid, p_customer_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_id uuid, account_name text, debit numeric, credit numeric, balance numeric, document_number text, document_id uuid, transaction_source_type integer)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_opening_equity_id UUID;
    v_sundary_detors_account_id UUID;
    v_opening_balance_equity_account_id UUID;
BEGIN
 
  SELECT accounts_receivable_account_id, opening_balance_equity_account_id 
  INTO v_sundary_detors_account_id, v_opening_balance_equity_account_id
  FROM public.organization_accounts
  WHERE organization_id = p_organization_id
  LIMIT 1;

  RETURN QUERY
  WITH all_transactions AS (
      SELECT
          th.transaction_date::date,
          coa.name AS account_name,
          coa.id AS account_id,          -- ✅ Include account_id
          CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END AS debit,
          CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END AS credit,
          th.document_number,
          th.document_id,
          th.transaction_source_type,
          tst.sort_order,
          th.id AS transaction_id,
          je.id AS journal_entry_id
      FROM
          public.transaction_headers th
      JOIN public.journal_entries je ON th.id = je.transaction_id
      JOIN public.transaction_source_types tst ON th.transaction_source_type = tst.id
      JOIN public.chart_of_accounts coa ON je.account_id = coa.id
      WHERE
          th.company_id = p_company_id
          AND th.customer_id = p_customer_id
          AND je.account_id = v_sundary_detors_account_id
          AND th.transaction_date BETWEEN p_start_date AND p_end_date
          AND th.is_deleted = false
          AND je.is_deleted = false
  )
  SELECT
      at.transaction_date,
      at.account_id,                     -- ✅ Added here
      at.account_name,
      at.debit,
      at.credit,
      SUM(at.debit - at.credit) OVER (
          ORDER BY
              at.transaction_date,
              at.sort_order,
              at.transaction_id,
              at.journal_entry_id
      ) AS balance,
      at.document_number,
      at.document_id,
      at.transaction_source_type
  FROM all_transactions AS at
  ORDER BY
      at.transaction_date,
      at.sort_order,
      at.transaction_id,
      at.journal_entry_id;

END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_customer_ledger(p_company_id uuid, p_organization_id uuid, p_customer_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_name text, debit numeric, credit numeric, balance numeric, document_number text, document_id uuid, transaction_source_type integer, sort_order integer)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_opening_balance NUMERIC;
BEGIN
	SELECT COALESCE(
	        SUM(
	            CASE 
	                WHEN ob.entry_type = 'D' THEN ob.balance  -- Debit increases balance
	                ELSE -ob.balance                         -- Credit reduces balance
	            END
	        ), 0)
    INTO v_opening_balance
    FROM public.opening_balances ob
    WHERE ob.organization_id = p_organization_id 
      AND ob.customer_id = p_customer_id
      AND ob.is_deleted = FALSE;

    RETURN QUERY
    WITH customer_transactions AS (
        SELECT 
            th.transaction_date::date AS transaction_date,
            coa.name AS account_name,
            CASE 
                WHEN je.entry_type = 'D' THEN je.amount 
                ELSE 0 
            END AS debit,
            CASE 
                WHEN je.entry_type = 'C' THEN je.amount 
                ELSE 0 
            END AS credit,
            th.company_id,
            th.customer_id, 
            je.account_id,
            th.document_number,           
            th.document_id,
			th.transaction_source_type,
            2 AS sort_order
        FROM 
            public.transaction_headers th
        INNER JOIN 
            public.journal_entries je ON th.id = je.transaction_id  
        INNER JOIN 
            public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.company_id = p_company_id
            AND coa.organization_id = p_organization_id
            AND th.customer_id = p_customer_id 
            AND th.is_deleted = false 
            AND je.is_deleted = false
            AND th.transaction_date >= p_start_date  
            AND th.transaction_date <= p_end_date  
    )
    SELECT 
        p_start_date AS transaction_date, 
        'Opening Balance' AS account_name,
        0 AS debit,
        0 AS credit,
        v_opening_balance AS balance,
        NULL AS document_number,
        NULL AS document_id,
        NULL AS transaction_source_type,
        1 AS sort_order 
         
    UNION ALL 

    SELECT 
        ct.transaction_date,
        ct.account_name,
        ct.debit,
        ct.credit,
        v_opening_balance 
        + SUM(ct.debit - ct.credit) 
        OVER (ORDER BY ct.transaction_date, ct.document_number ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
        AS balance,
        ct.document_number,          
        ct.document_id,
        ct.transaction_source_type,
        ct.sort_order 
    FROM 
        customer_transactions ct
    WHERE 
        NOT (ct.debit = 0 AND ct.credit = 0)
    ORDER BY 
        transaction_date,
        sort_order ASC; -- Then order by transaction date
END;
$function$

-- Function: get_general_ledger
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_general_ledger(p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid, customer_id uuid, customer_name text, employee_id uuid, employee_name text, vendor_id uuid, vendor_name text)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH general_transactions AS (
        SELECT 
            th.transaction_date::date AS transaction_date,
            coa.name AS account_name,
            CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END AS debit,
            CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END AS credit,
            th.company_id,
            je.account_id,
            th.transaction_source_type,
            tst.sort_order,
            th.document_number,
            th.document_id,
            th.customer_id,
            th.employee_id,
            th.vendor_id,
            th.id AS transaction_id,
            je.id AS journal_entry_id
        FROM 
            public.transaction_headers th
        INNER JOIN 
            public.journal_entries je ON th.id = je.transaction_id
        INNER JOIN 
            public.chart_of_accounts coa ON je.account_id = coa.id
        INNER JOIN 
            public.transaction_source_types tst ON th.transaction_source_type = tst.id
        WHERE 
            th.company_id = p_company_id
            AND coa.organization_id = p_organization_id
            AND th.is_deleted = false
            AND je.is_deleted = false
            AND th.transaction_date BETWEEN p_start_date AND p_end_date
    )
    SELECT 
        gt.transaction_date,
        gt.account_name,
        gt.debit,
        gt.credit,
        SUM(gt.debit - gt.credit) OVER (
            ORDER BY 
                gt.transaction_date,
                gt.sort_order,
                gt.transaction_id,
                gt.journal_entry_id
        ) AS balance,
        gt.transaction_source_type,
        gt.document_number,
        gt.document_id,
        c.id AS customer_id,
        c.name::text AS customer_name,
        e.id AS employee_id,
        CASE 
            WHEN e.id IS NOT NULL THEN (e.first_name || ' ' || e.last_name)::text
            ELSE NULL
        END AS employee_name,
        v.id AS vendor_id,
        v.name::text AS vendor_name
    FROM 
        general_transactions gt
        LEFT JOIN public.customers c ON gt.customer_id = c.id AND c.company_id = p_company_id
        LEFT JOIN public.employees e ON gt.employee_id = e.id AND e.company_id = p_company_id
        LEFT JOIN public.vendors v ON gt.vendor_id = v.id AND v.company_id = p_company_id
    WHERE 
        NOT (gt.debit = 0 AND gt.credit = 0)
    ORDER BY 
        gt.transaction_date,
        gt.sort_order,
        gt.transaction_id,
        gt.journal_entry_id;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_general_ledger(p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH general_transactions AS (
        SELECT 
            th.transaction_date::date AS transaction_date, -- Cast to date
            coa.name AS account_name,
            CASE 
                WHEN je.entry_type = 'D' THEN je.amount 
                ELSE 0 
            END AS debit,
            CASE 
                WHEN je.entry_type = 'C' THEN je.amount 
                ELSE 0 
            END AS credit,
            th.company_id,
            je.account_id,
            th.transaction_source_type,   
            th.document_number,           
            th.document_id              
        FROM 
            public.transaction_headers th
        INNER JOIN 
            public.journal_entries je ON th.id = je.transaction_id  
        INNER JOIN 
            public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.company_id = p_company_id
            AND coa.organization_id = p_organization_id
            AND th.is_deleted = false 
            AND je.is_deleted = false
            AND th.transaction_date >= p_start_date  
            AND th.transaction_date <= p_end_date  
    )
    SELECT 
        gt.transaction_date,
        gt.account_name,
        gt.debit,
        gt.credit,
        -- Recalculate balance where debit and credit are settled
        SUM(gt.debit - gt.credit) OVER (PARTITION BY gt.account_id ORDER BY gt.transaction_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS balance,
        gt.transaction_source_type,   
        gt.document_number,          
        gt.document_id                
    FROM 
        general_transactions gt
    WHERE
        -- Exclude rows where both debit and credit are 0
        NOT (gt.debit = 0 AND gt.credit = 0)
    ORDER BY 
        gt.transaction_date;
END;
$function$

-- Function: get_vendor_ledger
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_vendor_ledger(p_vendor_id uuid, p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_id uuid, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_sundary_creditors_account_id UUID;
    v_vendor_advance_account_id UUID;
BEGIN
    SELECT 
        accounts_payable_account_id, 
        vendor_advance_account_id
    INTO 
        v_sundary_creditors_account_id, 
        v_vendor_advance_account_id
    FROM public.organization_accounts
    WHERE organization_id = p_organization_id
    LIMIT 1;

    RETURN QUERY
    WITH all_transactions AS (
        SELECT
            th.transaction_date::date,
            coa.id AS account_id,
            coa.name AS account_name,
            CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END AS debit,
            CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END AS credit,
            th.document_number,
            th.document_id,
            th.transaction_source_type,
            tst.sort_order,
            th.id AS transaction_id,
            je.id AS journal_entry_id
        FROM public.transaction_headers th
        JOIN public.journal_entries je ON th.id = je.transaction_id
        JOIN public.transaction_source_types tst ON th.transaction_source_type = tst.id
        JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE
            th.company_id = p_company_id
            AND th.vendor_id = p_vendor_id
            AND je.account_id IN (v_sundary_creditors_account_id, v_vendor_advance_account_id)
            AND th.transaction_date BETWEEN p_start_date AND p_end_date
            AND th.is_deleted = false
            AND je.is_deleted = false
    )
    SELECT
        at.transaction_date,
        at.account_id,
        at.account_name,
        at.debit,
        at.credit,
        SUM(at.debit - at.credit) OVER (
            ORDER BY 
                at.transaction_date, 
                at.sort_order, 
                at.transaction_id, 
                at.journal_entry_id
        ) AS balance,
        at.transaction_source_type,
        at.document_number,
        at.document_id
    FROM all_transactions AS at
    ORDER BY
        at.transaction_date,
        at.sort_order,
        at.transaction_id,
        at.journal_entry_id;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_vendor_ledger(p_vendor_id uuid, p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH vendor_transactions AS (
        SELECT 
            th.transaction_date::date AS transaction_date,  
            coa.name AS account_name,
            CASE 
                WHEN je.entry_type = 'D' THEN je.amount 
                ELSE 0 
            END AS debit,
            CASE 
                WHEN je.entry_type = 'C' THEN je.amount 
                ELSE 0 
            END AS credit,
            th.company_id,
            th.vendor_id,
            th.transaction_source_type,   
            th.document_number,           
            th.document_id              
        FROM 
            public.transaction_headers th
        INNER JOIN 
            public.journal_entries je ON th.id = je.transaction_id  
        INNER JOIN 
            public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.vendor_id = p_vendor_id
            AND th.company_id = p_company_id
            AND coa.organization_id = p_organization_id
            AND th.is_deleted = false 
            AND je.is_deleted = false
            AND th.transaction_date >= p_start_date   
            AND th.transaction_date <= p_end_date     
    )
    SELECT 
        vt.transaction_date,
        vt.account_name,
        vt.debit,
        vt.credit,
        SUM(vt.debit - vt.credit) OVER (PARTITION BY vt.vendor_id ORDER BY vt.transaction_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS balance,
        vt.transaction_source_type,   
        vt.document_number,           
        vt.document_id                
    FROM 
        vendor_transactions vt
    ORDER BY 
        vt.transaction_date;
END;
$function$

-- Function: get_party_totals
CREATE OR REPLACE FUNCTION public.get_party_totals(p_organization_id uuid, p_company_id uuid, p_start_date date, p_end_date date, p_party_type integer)
 RETURNS TABLE(id uuid, party_name text, company_id uuid, company_name text, total_invoiced numeric, total_received numeric, total_billed numeric, total_paid numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    CUSTOMER CONSTANT int := 1;
    VENDOR   CONSTANT int := 2;
BEGIN
    -- Customers

    IF p_party_type = CUSTOMER THEN
        RETURN QUERY
        SELECT
            th.customer_id AS id,
            MAX(cust.name) AS party_name,
            th.company_id,
            MAX(comp.name) AS company_name,
            COALESCE(SUM(CASE WHEN th.transaction_source_type = 1 AND je.entry_type = 'D' THEN je.amount ELSE 0 END), 0) AS total_invoiced,
            COALESCE(SUM(CASE WHEN th.transaction_source_type = 3 AND je.entry_type = 'D' THEN je.amount ELSE 0 END), 0) AS total_received,
            0::numeric AS total_billed,
            0::numeric AS total_paid
        FROM public.transaction_headers th
        JOIN public.journal_entries je ON je.transaction_id = th.id
        JOIN public.companies comp ON comp.id = th.company_id
        LEFT JOIN public.customers cust ON cust.id = th.customer_id
        WHERE comp.organization_id = p_organization_id
          AND (p_company_id IS NULL OR th.company_id = p_company_id)
          AND (p_start_date IS NULL OR th.transaction_date >= p_start_date)
          AND (p_end_date IS NULL OR th.transaction_date <= p_end_date)
          AND th.customer_id IS NOT NULL
        GROUP BY th.customer_id, th.company_id;

    -- Vendors
    ELSIF p_party_type = VENDOR THEN
        RETURN QUERY
        SELECT
            th.vendor_id AS id,
            MAX(vend.name) AS party_name,
            th.company_id,
            MAX(comp.name) AS company_name,
            0::numeric AS total_invoiced,
            0::numeric AS total_received,
            COALESCE(SUM(CASE WHEN th.transaction_source_type = 2 AND je.entry_type = 'D' THEN je.amount ELSE 0 END), 0) AS total_billed,
            COALESCE(SUM(CASE WHEN th.transaction_source_type = 4 AND je.entry_type = 'D' THEN je.amount ELSE 0 END), 0) AS total_paid
        FROM public.transaction_headers th
        JOIN public.journal_entries je ON je.transaction_id = th.id
        JOIN public.companies comp ON comp.id = th.company_id
        LEFT JOIN public.vendors vend ON vend.id = th.vendor_id
        WHERE comp.organization_id = p_organization_id
          AND (p_company_id IS NULL OR th.company_id = p_company_id)
          AND (p_start_date IS NULL OR th.transaction_date >= p_start_date)
          AND (p_end_date IS NULL OR th.transaction_date <= p_end_date)
          AND th.vendor_id IS NOT NULL
        GROUP BY th.vendor_id, th.company_id;

    END IF;
END;
$function$

-- Function: get_comparative_accounts_overview
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_comparative_accounts_overview(p_company_id uuid, p_fin_year_id integer)
 RETURNS TABLE(account_id uuid, account_name text, parent_account_id uuid, hierarchy_path text[], order_sequence text, financial_year integer, apr numeric, may numeric, jun numeric, jul numeric, aug numeric, sep numeric, oct numeric, nov numeric, "dec" numeric, jan numeric, feb numeric, mar numeric, total_sum numeric, difference numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE 
    v_current_year_id INTEGER := p_fin_year_id;
    v_previous_year_id INTEGER;
    v_organization_id UUID;
BEGIN
    -- Get organization
    SELECT c.organization_id INTO v_organization_id
    FROM public.companies c
    WHERE c.id = p_company_id;

    -- Find previous financial year (based on start_date)
    SELECT fy.id
    INTO v_previous_year_id
    FROM finance_year fy
    WHERE fy.start_date < (
        SELECT start_date FROM finance_year WHERE id = v_current_year_id
    )
    ORDER BY fy.start_date DESC
    LIMIT 1;

    RETURN QUERY
    WITH RECURSIVE account_with_path AS (
        -- Root accounts
        SELECT
            coa.id,
            coa.name,
            coa.parent_account_id,
            ARRAY[coa.name]::text[] AS path,
            coa.account_number::text AS order_sequence
        FROM chart_of_accounts coa
        WHERE coa.organization_id = v_organization_id
          AND (coa.parent_account_id IS NULL OR coa.parent_account_id = '00000000-0000-0000-0000-000000000000')
          AND coa.is_deleted = FALSE

        UNION ALL

        -- Children
        SELECT
            c.id,
            c.name,
            c.parent_account_id,
            awp.path || c.name,
            awp.order_sequence || '.' || c.account_number::text
        FROM chart_of_accounts c
        JOIN account_with_path awp ON c.parent_account_id = awp.id
        WHERE c.organization_id = v_organization_id
          AND c.is_deleted = FALSE
    ),
    leaf_accounts AS (
        SELECT a.id
        FROM account_with_path a
        WHERE NOT EXISTS (
            SELECT 1 FROM chart_of_accounts c
            WHERE c.parent_account_id = a.id
              AND c.organization_id = v_organization_id
              AND c.is_deleted = FALSE
        )
    ),
    financial_years AS (
        SELECT id AS fin_year_id, start_date, end_date
        FROM finance_year
        WHERE id IN (v_current_year_id, v_previous_year_id)
    ),
    aggregated_data AS (
        SELECT
            awp.id,
            awp.name,
            awp.parent_account_id,
            awp.path AS hierarchy_path,
            awp.order_sequence,
            fy.fin_year_id,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 4 THEN je.amount END), 0) AS apr,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 5 THEN je.amount END), 0) AS may,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 6 THEN je.amount END), 0) AS jun,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 7 THEN je.amount END), 0) AS jul,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 8 THEN je.amount END), 0) AS aug,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 9 THEN je.amount END), 0) AS sep,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 10 THEN je.amount END), 0) AS oct,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 11 THEN je.amount END), 0) AS nov,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 12 THEN je.amount END), 0) AS "dec",
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 1 THEN je.amount END), 0) AS jan,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 2 THEN je.amount END), 0) AS feb,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 3 THEN je.amount END), 0) AS mar
        FROM account_with_path awp
        JOIN leaf_accounts la ON la.id = awp.id         -- ✅ only leaf accounts get financial years
        CROSS JOIN financial_years fy
        LEFT JOIN journal_entries je 
               ON je.account_id = awp.id
              AND je.transaction_date BETWEEN fy.start_date AND fy.end_date
        LEFT JOIN transaction_headers th 
               ON th.id = je.transaction_id 
              AND th.company_id = p_company_id
        WHERE (th.transaction_source_type IS NULL OR th.transaction_source_type != 18)
        GROUP BY awp.id, awp.name, awp.parent_account_id, awp.path, awp.order_sequence, fy.fin_year_id
    )
    SELECT
        a1.id AS account_id,
        a1.name AS account_name,
        a1.parent_account_id,
        a1.hierarchy_path,
        a1.order_sequence,
        a1.fin_year_id AS financial_year,
        a1.apr, a1.may, a1.jun, a1.jul, a1.aug, a1.sep, a1.oct, a1.nov, a1."dec",
        a1.jan, a1.feb, a1.mar,
        (COALESCE(a1.apr,0) + COALESCE(a1.may,0) + COALESCE(a1.jun,0) +
         COALESCE(a1.jul,0) + COALESCE(a1.aug,0) + COALESCE(a1.sep,0) +
         COALESCE(a1.oct,0) + COALESCE(a1.nov,0) + COALESCE(a1."dec",0) +
         COALESCE(a1.jan,0) + COALESCE(a1.feb,0) + COALESCE(a1.mar,0)) AS total_sum,
        ((COALESCE(a1.apr,0) + COALESCE(a1.may,0) + COALESCE(a1.jun,0) +
          COALESCE(a1.jul,0) + COALESCE(a1.aug,0) + COALESCE(a1.sep,0) +
          COALESCE(a1.oct,0) + COALESCE(a1.nov,0) + COALESCE(a1."dec",0) +
          COALESCE(a1.jan,0) + COALESCE(a1.feb,0) + COALESCE(a1.mar,0))
         -
         (COALESCE(a2.apr,0) + COALESCE(a2.may,0) + COALESCE(a2.jun,0) +
          COALESCE(a2.jul,0) + COALESCE(a2.aug,0) + COALESCE(a2.sep,0) +
          COALESCE(a2.oct,0) + COALESCE(a2.nov,0) + COALESCE(a2."dec",0) +
          COALESCE(a2.jan,0) + COALESCE(a2.feb,0) + COALESCE(a2.mar,0))
        ) AS difference
    FROM aggregated_data a1
    LEFT JOIN aggregated_data a2 
           ON a1.id = a2.id
          AND a1.fin_year_id = v_current_year_id
          AND a2.fin_year_id = v_previous_year_id
    ORDER BY a1.order_sequence, a1.fin_year_id;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_comparative_accounts_overview(p_company_id uuid, p_fin_year_id integer, p_chart_of_account_id uuid)
 RETURNS TABLE(account_id uuid, parent_account_name text, parent_account_id uuid, financial_year integer, apr numeric, may numeric, jun numeric, jul numeric, aug numeric, sep numeric, oct numeric, nov numeric, "dec" numeric, jan numeric, feb numeric, mar numeric, total_sum numeric, difference numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE 
    v_current_year INTEGER := p_fin_year_id;
    v_previous_year INTEGER := p_fin_year_id - 1;
    v_organization_id UUID;
    v_is_second_last_leaf BOOLEAN;
BEGIN
    -- Get the organization_id for the given company_id
    SELECT c.organization_id 
    INTO v_organization_id 
    FROM public.companies c
    WHERE c.id = p_company_id;

-- Search for 2nd last leaf account
		 SELECT NOT EXISTS (
		    SELECT 1 FROM chart_of_accounts ca1
		    WHERE ca1.parent_account_id = p_chart_of_account_id
		    )
		 INTO v_is_second_last_leaf;
		 


    RAISE notice 'it is leaf account %', v_is_second_last_leaf;

    -- If it is a LEAF account, fetch its transactions directly
    IF v_is_second_last_leaf THEN
    RETURN QUERY
    WITH RECURSIVE child_accounts AS (
        -- Get the given parent account and all its child accounts
        SELECT id, parent_account_id, name 
        FROM chart_of_accounts 
        WHERE parent_account_id = p_chart_of_account_id

        UNION ALL

        -- Recursively get all child accounts
        SELECT ca.id, ca.parent_account_id, ca.name 
        FROM chart_of_accounts ca
        INNER JOIN child_accounts c ON ca.parent_account_id = c.id
    ),
    financial_years AS (
        -- Get previous and current financial years
        SELECT fy.id AS fin_year_id, fy.start_date, fy.end_date 
        FROM finance_year fy 
        WHERE fy.id IN (v_previous_year, v_current_year)
    )
    SELECT 
        je.id AS transaction_id,
        je.account_id,
        ca.name AS account_name,
        ca.parent_account_id,
        fy.fin_year_id AS financial_year,
        je.transaction_date,
        EXTRACT(MONTH FROM je.transaction_date) AS calendar_month,
        
        -- Convert Calendar Month to Financial Month (April - March Cycle)
        CASE 
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 4 THEN 'Apr'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 5 THEN 'May'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 6 THEN 'Jun'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 7 THEN 'Jul'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 8 THEN 'Aug'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 9 THEN 'Sep'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 10 THEN 'Oct'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 11 THEN 'Nov'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 12 THEN 'Dec'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 1 THEN 'Jan'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 2 THEN 'Feb'
            WHEN EXTRACT(MONTH FROM je.transaction_date) = 3 THEN 'Mar'
        END AS financial_month,

        je.amount,
        je.description
    FROM journal_entries je
    INNER JOIN child_accounts ca ON je.account_id = ca.id
    INNER JOIN financial_years fy ON je.transaction_date BETWEEN fy.start_date AND fy.end_date
    ORDER BY fy.fin_year_id, financial_month, ca.name, je.transaction_date;

    ELSE
        -- If it is NOT a leaf account, use the ORIGINAL FUNCTIONALITY (recursive aggregation)
       RETURN QUERY
    WITH direct_children AS (
        -- Step 1: Get Direct Children of Given Parent
        SELECT ca.id AS account_id, ca.parent_account_id, ca.name
        FROM chart_of_accounts ca
        WHERE ca.parent_account_id = p_chart_of_account_id
		 AND ca.organization_id = v_organization_id
    ),

    descendant_accounts AS (
        -- Step 2: Recursively Get All Descendants of Each Direct Child
        WITH RECURSIVE hierarchy AS (
            -- Start with direct children
            SELECT dc.account_id, dc.parent_account_id, dc.name
            FROM direct_children dc

            UNION ALL

            -- Then, recursively get all their descendants
            SELECT coa.id AS account_id, coa.parent_account_id, coa.name
            FROM chart_of_accounts coa
            INNER JOIN hierarchy h ON coa.parent_account_id = h.account_id
        )
        SELECT * FROM hierarchy
    ),

    financial_years AS (
        -- Step 3: Get Start and End Dates for Given Financial Years
        SELECT id AS fin_year_id, start_date, end_date 
        FROM finance_year 
        WHERE id IN (v_previous_year, v_current_year)
    ),

    aggregated_data AS (
        -- Step 4: Ensure Each Account Appears for Both Financial Years
        SELECT 
            dc.account_id,            -- Include Account ID
            dc.name AS parent_account_name, 
            dc.parent_account_id,      -- Ensure Parent Account ID is properly referenced
            fy.fin_year_id AS financial_year,

            -- Monthly Values (April to March)
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 4 THEN je.amount ELSE 0 END), 0) AS apr,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 5 THEN je.amount ELSE 0 END), 0) AS may,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 6 THEN je.amount ELSE 0 END), 0) AS jun,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 7 THEN je.amount ELSE 0 END), 0) AS jul,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 8 THEN je.amount ELSE 0 END), 0) AS aug,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 9 THEN je.amount ELSE 0 END), 0) AS sep,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 10 THEN je.amount ELSE 0 END), 0) AS oct,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 11 THEN je.amount ELSE 0 END), 0) AS nov,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 12 THEN je.amount ELSE 0 END), 0) AS "dec",
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 1 THEN je.amount ELSE 0 END), 0) AS jan,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 2 THEN je.amount ELSE 0 END), 0) AS feb,
            COALESCE(SUM(CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 3 THEN je.amount ELSE 0 END), 0) AS mar,

            -- Total Sum of All Months
            COALESCE(SUM(je.amount), 0) AS total_sum

        FROM direct_children dc
        CROSS JOIN financial_years fy  -- Ensures each account appears for both years
        LEFT JOIN descendant_accounts da ON da.parent_account_id = dc.account_id
        LEFT JOIN journal_entries je 
            ON je.account_id = da.account_id
            AND je.transaction_date BETWEEN fy.start_date AND fy.end_date  -- Ensure correct year filtering
           -- AND je.company_id = p_company_id -- Filter by Company ID

        GROUP BY dc.account_id, dc.parent_account_id, dc.name, fy.fin_year_id
    )

    -- Step 5: Compute Difference Between Two Financial Years
    SELECT 
        a1.account_id,
        a1.parent_account_name,
        a1.parent_account_id,
        a1.financial_year,

        -- Monthly Values
        a1.apr, a1.may, a1.jun, a1.jul, a1.aug, a1.sep, a1.oct, a1.nov, a1."dec",
        a1.jan, a1.feb, a1.mar,

        -- Total Sum for Financial Year
        a1.total_sum,

        -- Difference (Current Year - Previous Year)
        (COALESCE(a1.total_sum, 0) - COALESCE(a2.total_sum, 0)) AS difference

    FROM aggregated_data a1
    LEFT JOIN aggregated_data a2
        ON a1.account_id = a2.account_id
        AND a1.financial_year = v_current_year  -- Current Year
        AND a2.financial_year = v_previous_year  -- Previous Year

    ORDER BY a1.parent_account_name, a1.financial_year;
    END IF;
END;
$function$

-- Function: update_basic_company
CREATE OR REPLACE FUNCTION public.update_basic_company(p_company_id uuid, p_organization_id uuid, p_name text, p_gst_in text, p_short_name text, p_currency text, p_pan text, p_tan text, p_outstanding_limit numeric, p_is_apartment boolean, p_is_non_work boolean, p_interest_percentage numeric, p_has_gst_in boolean, p_email text, p_mobile_number text)
 RETURNS void
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_contact_id UUID;
BEGIN
    -- 1️⃣ Get contact_id from company_contacts
    SELECT contact_id INTO v_contact_id
    FROM company_contacts
    WHERE company_id = p_company_id
    LIMIT 1;

    -- 2️⃣ Update company table
    UPDATE companies
    SET 
        organization_id   = p_organization_id,
        name              = p_name,
        gst_in            = p_gst_in,
        short_name        = p_short_name,
        currency          = p_currency,
        pan               = p_pan,
        tan               = p_tan,
        outstanding_limit = p_outstanding_limit,
        is_apartment      = p_is_apartment,
        is_non_work       = p_is_non_work,
        interest_percentage = p_interest_percentage,
        has_gst_in        = p_has_gst_in,
        modified_on_utc   = NOW()
    WHERE id = p_company_id;

    -- 3️⃣ Update contact table if mapping exists
    IF v_contact_id IS NOT NULL THEN
        UPDATE contacts
        SET 
            email = p_email,
            mobile_number = p_mobile_number,
            modified_on_utc = NOW()
        WHERE id = v_contact_id;
    END IF;

END;
$function$

-- Function: pgp_sym_decrypt
CREATE OR REPLACE FUNCTION public.pgp_sym_decrypt(bytea, text)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_decrypt_text$function$

-- Function: pgp_sym_decrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_sym_decrypt_bytea(bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_decrypt_bytea$function$

-- Function: get_module_permissions
CREATE OR REPLACE FUNCTION public.get_module_permissions()
 RETURNS TABLE(id integer, feature_name text, read_permission_id uuid, create_permission_id uuid, update_permission_id uuid, delete_permission_id uuid, full_access_permission_id uuid, created_on_utc timestamp without time zone, modified_on_utc timestamp without time zone, deleted_on_utc timestamp without time zone, is_deleted boolean, created_by uuid, modified_by uuid)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    SELECT 
        mp.id,
        mp.feature_name,
        mp.read_permission_id,
        mp.create_permission_id,
        mp.update_permission_id,
        mp.delete_permission_id,
        mp.full_access_permission_id,
        mp.created_on_utc,
        mp.modified_on_utc,
        mp.deleted_on_utc,
        mp.is_deleted,
        mp.created_by,
        mp.modified_by
    FROM module_permissions mp
    WHERE mp.is_deleted = false
    ORDER BY mp.feature_name;
END;
$function$

-- Function: get_profit_loss_statement
CREATE OR REPLACE FUNCTION public.get_profit_loss_statement(p_company_id uuid, p_fin_year_id integer, p_start_date date, p_end_date date, p_is_get_for_organization boolean)
 RETURNS TABLE(account_id uuid, account_type text, account_name text, amount numeric, category text)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_start_date date;
    v_end_date date;
    v_fy_start_date date;
    v_fy_end_date date;
    v_company_ids UUID[];
    v_organization_id UUID;
    income_account_ids integer[];
    expense_account_ids integer[];
BEGIN
    -- Get the financial year dates
    SELECT start_date::date, end_date::date
    INTO v_fy_start_date, v_fy_end_date
    FROM public.finance_year
    WHERE id = p_fin_year_id
    LIMIT 1;

    -- Apply filter logic for new date params
    v_start_date := COALESCE(p_start_date, v_fy_start_date);
    v_end_date := COALESCE(p_end_date, v_fy_end_date);

    -- Get organization id
    SELECT organization_id INTO v_organization_id 
    FROM public.companies 
    WHERE id = p_company_id;

    -- Get account type hierarchies
    income_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(4));
    expense_account_ids := ARRAY(SELECT id FROM get_account_type_hierarchy(5));

    -- Populate company IDs based on org flag
    IF p_is_get_for_organization THEN
        SELECT ARRAY(
            SELECT id FROM companies 
            WHERE organization_id = v_organization_id
        )
        INTO v_company_ids;
    ELSE
        v_company_ids := ARRAY[p_company_id];
    END IF;

    -- Return Income
    RETURN QUERY
    SELECT
        coa.id as account_id,                  -- GUID column
        at.name AS account_type,
        coa.name AS account_name,
        COALESCE(
            SUM(
                CASE
                    WHEN ob.entry_type = 'C' THEN ob.balance
                    ELSE -ob.balance 
                END
            ),0
        ) +
        COALESCE(
            SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE -je.amount END), 0
        ) AS amount,
        'Income' AS category
    FROM public.chart_of_accounts coa
    INNER JOIN public.journal_entries je ON je.account_id = coa.id
    INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
    INNER JOIN public.account_types at ON coa.account_type_id = at.id
    LEFT JOIN public.opening_balances ob ON ob.account_id = coa.id
        AND ob.organization_id = v_organization_id
        AND ob.finyear_id = p_fin_year_id
        AND ob.is_deleted = FALSE
    WHERE th.company_id = ANY(v_company_ids)
        AND th.transaction_date BETWEEN v_start_date AND v_end_date
        AND NOT th.is_deleted
        AND NOT je.is_deleted
        AND coa.account_type_id = ANY(income_account_ids)
    GROUP BY coa.id, at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;

    -- Return Expenses
    RETURN QUERY
    SELECT
        coa.id as account_id,                  -- GUID column
        at.name AS account_type,
        coa.name AS account_name,
        COALESCE(
            SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE -je.amount END), 0
        ) AS amount,
        'Expenses' AS category
    FROM public.chart_of_accounts coa
    INNER JOIN public.journal_entries je ON je.account_id = coa.id
    INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
    INNER JOIN public.account_types at ON coa.account_type_id = at.id
    WHERE th.company_id = ANY(v_company_ids)
        AND th.transaction_date BETWEEN v_start_date AND v_end_date
        AND NOT th.is_deleted
        AND NOT je.is_deleted
        AND coa.account_type_id = ANY(expense_account_ids)
    GROUP BY coa.id, at.name, coa.name, coa.account_number, at.id
    ORDER BY coa.account_number, at.id;
END;
$function$

-- Function: pgp_sym_encrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_sym_encrypt_bytea(bytea, text, text)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_encrypt_bytea$function$

-- Function: get_trial_balance_of_company_fin_year
CREATE OR REPLACE FUNCTION public.get_trial_balance_of_company_fin_year(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(account_type text, account_category text, account_number text, account_name text, total_debits numeric, total_credits numeric)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH RECURSIVE coa_hierarchy AS (
        -- Base case: Fetch the top-level (root) accounts
        SELECT
            coa.id,
            act.name AS account_type,
            act.classification AS account_classification,
            coa.account_number::integer,
            coa.name,
            coa.parent_account_id,
            0 AS level,
            coa.account_number::text AS order_sequence
        FROM 
            public.chart_of_accounts coa
        INNER JOIN
            public.account_types act ON coa.account_type_id = act.id
        WHERE
            coa.is_deleted = FALSE
            AND coa.parent_account_id = '00000000-0000-0000-0000-000000000000' -- Root-level accounts

        UNION ALL

        -- Recursive case: Fetch child accounts
        SELECT 
            coa.id,
            act.name AS account_type,
            act.classification AS account_classification,
            coa.account_number::integer,
            coa.name,
            coa.parent_account_id,
            ch.level + 1 AS level,
            ch.order_sequence || '.' || coa.account_number::text AS order_sequence
        FROM 
            public.chart_of_accounts coa
        INNER JOIN
            public.account_types act ON coa.account_type_id = act.id
        INNER JOIN 
            coa_hierarchy ch ON ch.id = coa.parent_account_id
        WHERE
            coa.is_deleted = FALSE
    ),
    coa_with_balances AS (
        -- Fetch financial year start and end date
        SELECT
            fy.start_date::DATE, 
            fy.end_date::DATE
        FROM
            public.finance_year fy
        WHERE
            fy.id = p_finance_year_id
        LIMIT 1
    ),
    journal_entries_filtered AS (
        -- Get total debits and credits per account
        SELECT 
            je.account_id,
            SUM(CASE 
                WHEN je.entry_type = 'D' THEN je.amount 
                ELSE 0 
            END) AS total_debits,
            SUM(CASE 
                WHEN je.entry_type = 'C' THEN je.amount 
                ELSE 0 
            END) AS total_credits
        FROM 
            public.journal_entries je
        JOIN 
            public.transaction_headers th ON je.transaction_id = th.id
        JOIN 
            coa_with_balances fy ON th.transaction_date BETWEEN fy.start_date AND fy.end_date
        WHERE 
            th.company_id = p_company_id
            AND je.is_deleted = FALSE
        GROUP BY 
            je.account_id
        HAVING 
            SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END) > 0 OR
            SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END) > 0
    ),
    relevant_accounts AS (
        -- Select accounts that have balances
        SELECT 
            ch.id, 
            ch.account_type, 
            ch.account_classification,
            ch.account_number, 
            ch.name, 
            ch.level, 
            ch.order_sequence, 
            ch.parent_account_id,
            wb.total_debits, 
            wb.total_credits
        FROM 
            coa_hierarchy ch
        LEFT JOIN 
            journal_entries_filtered wb ON ch.id = wb.account_id
        WHERE 
            wb.account_id IS NOT NULL  

        UNION ALL

        -- Recursively select parent accounts
        SELECT 
            ch.id, 
            ch.account_type, 
            ch.account_classification,
            ch.account_number, 
            ch.name, 
            ch.level, 
            ch.order_sequence, 
            ch.parent_account_id,
            NULL AS total_debits, 
            NULL AS total_credits
        FROM 
            coa_hierarchy ch
        INNER JOIN 
            relevant_accounts ra ON ch.id = ra.parent_account_id  
    )
    -- Final output
    SELECT DISTINCT ON (ra.order_sequence)
        ra.account_type::TEXT AS account_type,
        ac.name::TEXT AS account_category,
        ra.account_number::TEXT AS account_number,
        LPAD('', ra.level * 4, ' ') || ra.name::TEXT AS account_name,
        CASE 
            WHEN ra.account_classification = 'EXPENSES' THEN COALESCE(ra.total_credits, 0)  -- Expenses should be on the debit side
            ELSE COALESCE(ra.total_debits, 0)
        END AS total_debits,
        CASE 
            WHEN ra.account_classification = 'EXPENSES' THEN COALESCE(ra.total_debits, 0)  -- Expenses should not appear on the credit side
            ELSE COALESCE(ra.total_credits, 0)
        END AS total_credits
    FROM 
        relevant_accounts ra
    LEFT JOIN 
        public.chart_of_accounts coa ON ra.id = coa.id
    LEFT JOIN 
        public.account_types at ON coa.account_type_id = at.id
    LEFT JOIN 
        public.account_categories ac ON at.account_category_id = ac.id
    CROSS JOIN 
        coa_with_balances fy
    ORDER BY 
        ra.order_sequence;
END;
$function$

-- Function: pgp_sym_decrypt
CREATE OR REPLACE FUNCTION public.pgp_sym_decrypt(bytea, text, text)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_decrypt_text$function$

-- Function: digest
CREATE OR REPLACE FUNCTION public.digest(text, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_digest$function$

-- Function: digest
CREATE OR REPLACE FUNCTION public.digest(bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_digest$function$

-- Function: hmac
CREATE OR REPLACE FUNCTION public.hmac(text, text, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_hmac$function$

-- Function: hmac
CREATE OR REPLACE FUNCTION public.hmac(bytea, bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_hmac$function$

-- Function: crypt
CREATE OR REPLACE FUNCTION public.crypt(text, text)
 RETURNS text
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_crypt$function$

-- Function: gen_salt
CREATE OR REPLACE FUNCTION public.gen_salt(text)
 RETURNS text
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_gen_salt$function$

-- Function: gen_salt
CREATE OR REPLACE FUNCTION public.gen_salt(text, integer)
 RETURNS text
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_gen_salt_rounds$function$

-- Function: encrypt
CREATE OR REPLACE FUNCTION public.encrypt(bytea, bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_encrypt$function$

-- Function: decrypt
CREATE OR REPLACE FUNCTION public.decrypt(bytea, bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_decrypt$function$

-- Function: encrypt_iv
CREATE OR REPLACE FUNCTION public.encrypt_iv(bytea, bytea, bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_encrypt_iv$function$

-- Function: decrypt_iv
CREATE OR REPLACE FUNCTION public.decrypt_iv(bytea, bytea, bytea, text)
 RETURNS bytea
 LANGUAGE c
 IMMUTABLE PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_decrypt_iv$function$

-- Function: gen_random_bytes
CREATE OR REPLACE FUNCTION public.gen_random_bytes(integer)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pg_random_bytes$function$

-- Function: gen_random_uuid
CREATE OR REPLACE FUNCTION public.gen_random_uuid()
 RETURNS uuid
 LANGUAGE c
 PARALLEL SAFE
AS '$libdir/pgcrypto', $function$pg_random_uuid$function$

-- Function: pgp_sym_encrypt
CREATE OR REPLACE FUNCTION public.pgp_sym_encrypt(text, text)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_encrypt_text$function$

-- Function: pgp_sym_encrypt_bytea
CREATE OR REPLACE FUNCTION public.pgp_sym_encrypt_bytea(bytea, text)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_encrypt_bytea$function$

-- Function: pgp_sym_encrypt
CREATE OR REPLACE FUNCTION public.pgp_sym_encrypt(text, text, text)
 RETURNS bytea
 LANGUAGE c
 PARALLEL SAFE STRICT
AS '$libdir/pgcrypto', $function$pgp_sym_encrypt_text$function$

-- Function: get_bank_statements_for_status
CREATE OR REPLACE FUNCTION public.get_bank_statements_for_status(p_company_id uuid, p_finyear_id integer, p_date_from timestamp without time zone DEFAULT NULL::timestamp without time zone, p_date_to timestamp without time zone DEFAULT NULL::timestamp without time zone)
 RETURNS TABLE(id integer, company_id uuid, bank_id integer, bank_name text, txn_date timestamp without time zone, cheque_number character varying, description text, value_date timestamp without time zone, branch_code character varying, debit_amount numeric, credit_amount numeric, balance numeric, has_reconciled boolean, reconciliation_status_id integer, reconciliation_status text, reconciliation_description text, created_by uuid, created_on_utc timestamp without time zone, modified_by uuid, modified_on_utc timestamp without time zone, deleted_on_utc timestamp without time zone, is_deleted boolean)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    SELECT 
        bs.id,
        bs.company_id,
        bs.bank_id,
        b.name AS bank_name,
        bs.txn_date::timestamp,
        bs.cheque_number,
        bs.description,
        bs.value_date::timestamp,
        bs.branch_code,
        bs.debit_amount,
        bs.credit_amount,
        bs.balance,

        -- 🧠 Smart has_reconciled logic
        CASE 
            WHEN br.id IS NOT NULL 
                 AND rs.status IN ('partial', 'matched', 'audited') THEN TRUE
            ELSE FALSE
        END AS has_reconciled,

        -- 🧩 New reconciliation info
        rs.id AS reconciliation_status_id,
        rs.status::text AS reconciliation_status,
        rs.description::text AS reconciliation_description,

        bs.created_by,
        bs.created_on_utc,
        bs.modified_by,
        bs.modified_on_utc,
        bs.deleted_on_utc,
        bs.is_deleted
    FROM public.bank_statements bs
    INNER JOIN public.banks b 
        ON b.id = bs.bank_id
       AND b.is_deleted = false
    INNER JOIN public.finance_year fy
        ON fy.id = p_finyear_id
    LEFT JOIN LATERAL (
        SELECT br.*
        FROM public.bank_reconciliations br
        WHERE br.bank_statement_id = bs.id
        ORDER BY br.matched_on_utc DESC
        LIMIT 1
    ) br ON TRUE
    LEFT JOIN public.reconciliation_statuses rs 
        ON rs.id = br.reconciliation_status_id
    WHERE bs.company_id = p_company_id
      AND bs.txn_date BETWEEN fy.start_date AND fy.end_date
      AND (p_date_from IS NULL OR bs.txn_date >= p_date_from)
      AND (p_date_to IS NULL OR bs.txn_date <= p_date_to)
      AND bs.is_deleted = false
    ORDER BY bs.txn_date, bs.id;
END;
$function$

-- Function: get_account_expense_breakdown
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_account_expense_breakdown(p_company_id uuid, p_finance_id integer, p_period_type integer, p_period integer)
 RETURNS TABLE(account_id uuid, account_name text, account_number text, total_expense numeric, financial_year text)
 LANGUAGE plpgsql
 STABLE PARALLEL SAFE
AS $function$
DECLARE
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_finance_year TEXT;
    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
    CONST_YTD CONSTANT INTEGER := 5;
BEGIN
    -- Fetch financial year details
    SELECT fy.start_date, fy.end_date, fy.year
    INTO v_financial_year_start, v_financial_year_end, v_finance_year
    FROM public.finance_year fy
    WHERE fy.id = p_finance_id;

    IF v_financial_year_start IS NULL OR v_financial_year_end IS NULL THEN
        RAISE EXCEPTION 'Invalid financial year ID: %', p_finance_id;
    END IF;

    IF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND EXTRACT(MONTH FROM je.transaction_date) = (p_period + 3) % 12 + 1
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND (
                (p_period = 1 AND EXTRACT(MONTH FROM je.transaction_date) IN (4, 5, 6)) OR
                (p_period = 2 AND EXTRACT(MONTH FROM je.transaction_date) IN (7, 8, 9)) OR
                (p_period = 3 AND EXTRACT(MONTH FROM je.transaction_date) IN (10, 11, 12)) OR
                (p_period = 4 AND EXTRACT(MONTH FROM je.transaction_date) IN (1, 2, 3))
            )
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND (
                (p_period = 1 AND EXTRACT(MONTH FROM je.transaction_date) BETWEEN 4 AND 9) OR
                (p_period = 2 AND (EXTRACT(MONTH FROM je.transaction_date) BETWEEN 10 AND 12 OR EXTRACT(MONTH FROM je.transaction_date) BETWEEN 1 AND 3))
            )
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSIF p_period_type = CONST_YTD THEN
        RETURN QUERY
        WITH recent_years AS (
            SELECT fy.id, fy.start_date, fy.end_date,
                fy.year AS financial_year_text
            FROM public.finance_year fy
            WHERE EXTRACT(YEAR FROM fy.start_date) >= EXTRACT(YEAR FROM CURRENT_DATE) - 4
              AND EXTRACT(YEAR FROM fy.start_date) <= EXTRACT(YEAR FROM CURRENT_DATE)
            ORDER BY fy.start_date DESC
            LIMIT 5
        ),
        base AS (
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
                ry.financial_year_text AS financial_year
            FROM recent_years ry
            LEFT JOIN public.journal_entries je
                ON je.transaction_date BETWEEN ry.start_date AND LEAST(
                    ry.end_date, 
                    CASE 
                        WHEN CURRENT_DATE BETWEEN ry.start_date AND ry.end_date 
                        THEN CURRENT_DATE 
                        ELSE ry.end_date 
                    END
                )
            LEFT JOIN public.transaction_headers th
                ON je.transaction_id = th.id
                AND th.company_id = p_company_id
            LEFT JOIN public.chart_of_accounts coa
                ON je.account_id = coa.id
            WHERE 
                coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
                AND (je.id IS NULL OR je.is_deleted = FALSE)
                AND (coa.name IS NULL OR coa.name NOT IN ('Rounding Gain'))
            GROUP BY coa.id, coa.name, coa.account_number, ry.financial_year_text
        )
        SELECT
            base.account_id,
            base.account_name,
            base.account_number,
            SUM(base.total_expense) AS total_expense,
            base.financial_year
        FROM base
        GROUP BY base.account_id, base.account_name, base.account_number, base.financial_year
        ORDER BY base.financial_year DESC, total_expense DESC;     

    ELSE
        RAISE EXCEPTION 'Invalid period type: %', p_period_type;
    END IF;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_account_expense_breakdown(p_company_id uuid, p_finance_id integer, p_period_type integer, p_period integer)
 RETURNS TABLE(account_id uuid, account_name text, account_number text, total_expense numeric, financial_year text)
 LANGUAGE plpgsql
 STABLE PARALLEL SAFE
AS $function$
DECLARE
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_finance_year TEXT;

    -- Period type constants
    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
BEGIN
    -- Fetch financial year details
    SELECT fy.start_date, fy.end_date, fy.year 
    INTO v_financial_year_start, v_financial_year_end, v_finance_year
    FROM public.finance_year fy
    WHERE fy.id = p_finance_id;

    -- Validate financial year
    IF v_financial_year_start IS NULL OR v_financial_year_end IS NULL THEN
        RAISE EXCEPTION 'Invalid financial year ID: %', p_finance_id;
    END IF;

    -- Period-based filtering
    IF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM 
            public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND EXTRACT(MONTH FROM je.transaction_date) = (p_period + 3) % 12 + 1
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')  
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM 
            public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND (
                (p_period = 1 AND EXTRACT(MONTH FROM je.transaction_date) IN (4, 5, 6)) OR
                (p_period = 2 AND EXTRACT(MONTH FROM je.transaction_date) IN (7, 8, 9)) OR
                (p_period = 3 AND EXTRACT(MONTH FROM je.transaction_date) IN (10, 11, 12)) OR
                (p_period = 4 AND EXTRACT(MONTH FROM je.transaction_date) IN (1, 2, 3))
            )
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')  
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM 
            public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND (
                (p_period = 1 AND EXTRACT(MONTH FROM je.transaction_date) BETWEEN 4 AND 9) OR
                (p_period = 2 AND (EXTRACT(MONTH FROM je.transaction_date) BETWEEN 10 AND 12 OR EXTRACT(MONTH FROM je.transaction_date) BETWEEN 1 AND 3))
            )
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')  
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        SELECT 
            coa.id AS account_id,
            coa.name AS account_name,
            coa.account_number,
            ROUND(COALESCE(SUM(je.amount), 0), 2) AS total_expense,
            v_finance_year AS financial_year
        FROM 
            public.journal_entries je
        INNER JOIN public.transaction_headers th ON je.transaction_id = th.id
        INNER JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.company_id = p_company_id
            AND coa.account_type_id IN (SELECT id FROM get_account_type_hierarchy(5))
            AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.is_deleted = FALSE
            AND coa.name NOT IN ('Rounding Gain')  
        GROUP BY coa.id, coa.name, coa.account_number, v_finance_year
        ORDER BY total_expense DESC;

    ELSE
        RAISE EXCEPTION 'Invalid period type: %', p_period_type;
    END IF;
END;
$function$

-- Function: verify_user_password
CREATE OR REPLACE FUNCTION public.verify_user_password(p_user_name text, p_password text)
 RETURNS uuid
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_user_id UUID;
BEGIN
    SELECT id
    INTO v_user_id
    FROM users
    WHERE user_name = p_user_name
      AND is_deleted = false
      AND password_hash = crypt(p_password, password_hash);

    RETURN v_user_id;
END;
$function$

-- Function: get_account_ledger
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_account_ledger(p_account_id uuid, p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid, customer_id uuid, customer_name text, employee_id uuid, employee_name text, vendor_id uuid, vendor_name text)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH RECURSIVE account_tree AS (
        SELECT id
        FROM public.chart_of_accounts
        WHERE id = p_account_id
          AND organization_id = p_organization_id
          AND is_deleted = false
        UNION ALL
        SELECT coa.id
        FROM public.chart_of_accounts coa
        INNER JOIN account_tree at ON coa.parent_account_id = at.id
        WHERE coa.organization_id = p_organization_id
          AND coa.is_deleted = false
    ),
    account_transactions AS (
        SELECT 
            th.transaction_date::date AS transaction_date,
            coa.name AS account_name,
            coa.id AS account_id,
            CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END AS debit,
            CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END AS credit,
            th.document_number,
            th.document_id,
            th.transaction_source_type,
            tst.sort_order,
            th.id AS transaction_id,
            je.id AS journal_entry_id,
            th.customer_id,
            th.employee_id,
            th.vendor_id
        FROM 
            public.transaction_headers th
        INNER JOIN 
            public.journal_entries je ON th.id = je.transaction_id  
        INNER JOIN 
            public.chart_of_accounts coa ON je.account_id = coa.id
        INNER JOIN 
            account_tree at ON je.account_id = at.id
        INNER JOIN 
            public.transaction_source_types tst ON th.transaction_source_type = tst.id
        WHERE 
            th.company_id = p_company_id
            AND coa.organization_id = p_organization_id
            AND th.is_deleted = false 
            AND je.is_deleted = false
            AND th.transaction_date BETWEEN p_start_date AND p_end_date
    )
    SELECT 
        at.transaction_date,
        at.account_name,
        at.debit,
        at.credit,
        SUM(at.debit - at.credit) OVER (
            ORDER BY 
                at.transaction_date,
                at.sort_order,
                at.transaction_id,
                at.journal_entry_id
        ) AS balance,
        at.transaction_source_type,   
        at.document_number,          
        at.document_id,
        c.id AS customer_id,
        c.name::text AS customer_name,
        e.id AS employee_id,
        CASE 
            WHEN e.id IS NOT NULL THEN (e.first_name || ' ' || e.last_name)::text
            ELSE NULL
        END AS employee_name,
        v.id AS vendor_id,
        v.name::text AS vendor_name
    FROM 
        account_transactions at
        LEFT JOIN public.customers c ON at.customer_id = c.id AND c.company_id = p_company_id
        LEFT JOIN public.employees e ON at.employee_id = e.id AND e.company_id = p_company_id
        LEFT JOIN public.vendors v ON at.vendor_id = v.id AND v.company_id = p_company_id
    WHERE
        NOT (at.debit = 0 AND at.credit = 0)
    ORDER BY 
        at.transaction_date,
        at.sort_order,
        at.transaction_id,
        at.journal_entry_id;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_account_ledger(p_account_id uuid, p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH account_transactions AS (
        SELECT 
            th.transaction_date::date AS transaction_date, -- Cast to date
            coa.name AS account_name,
            CASE 
                WHEN je.entry_type = 'D' THEN je.amount 
                ELSE 0 
            END AS debit,
            CASE 
                WHEN je.entry_type = 'C' THEN je.amount 
                ELSE 0 
            END AS credit,
            th.company_id,
            je.account_id,
            th.transaction_source_type,   
            th.document_number,           
            th.document_id              
        FROM 
            public.transaction_headers th
        INNER JOIN 
            public.journal_entries je ON th.id = je.transaction_id  
        INNER JOIN 
            public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            je.account_id = p_account_id
            AND th.company_id = p_company_id
            AND coa.organization_id = p_organization_id
            AND th.is_deleted = false 
            AND je.is_deleted = false
            AND th.transaction_date >= p_start_date  
            AND th.transaction_date <= p_end_date  
    )
    SELECT 
        at.transaction_date,
        at.account_name,
        at.debit,
        at.credit,
        SUM(at.debit - at.credit) OVER (PARTITION BY at.account_id ORDER BY at.transaction_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS balance,
        at.transaction_source_type,   
        at.document_number,          
        at.document_id                
    FROM 
        account_transactions at
	WHERE
		NOT (at.debit = 0 AND at.credit = 0)
    ORDER BY 
        at.transaction_date;
END;
$function$

-- Function: get_account_transactions
CREATE OR REPLACE FUNCTION public.get_account_transactions(p_company_id uuid, p_fin_year_id integer, p_chart_of_account_id uuid)
 RETURNS TABLE(account_id uuid, account_name text, parent_account_id uuid, account_type text, year integer, apr numeric, may numeric, jun numeric, jul numeric, aug numeric, sep numeric, oct numeric, nov numeric, "dec" numeric, jan numeric, feb numeric, mar numeric, total_current_year numeric, total_last_year numeric, difference numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_start_date TIMESTAMP DEFAULT NULL;
    v_end_date TIMESTAMP DEFAULT NULL;
    v_prev_start_date TIMESTAMP DEFAULT NULL;
    v_prev_end_date TIMESTAMP DEFAULT NULL;
BEGIN
    -- Get start and end date for the given financial year(fn)
    SELECT fn.start_date, fn.end_date 
    INTO v_start_date, v_end_date
    FROM finance_year fn
    WHERE fn.id  = p_fin_year_id
    LIMIT 1;

    -- If no result, raise an error
    IF v_start_date IS NULL OR v_end_date IS NULL THEN
        RAISE EXCEPTION 'Financial year % not found in finance_year table', p_fin_year_id;
    END IF;

    -- Get the previous financial year's(pfn) start and end date
    SELECT pfn.start_date, pfn.end_date 
    INTO v_prev_start_date, v_prev_end_date
    FROM finance_year pfn
    WHERE pfn.id = (p_fin_year_id - 1)
    LIMIT 1;

    -- Return the final query
    RETURN QUERY 
    WITH direct_children AS (
        SELECT coa.id AS child_id, coa.name AS child_name, coa.parent_account_id AS direct_parent_id, coa.account_type_id
        FROM chart_of_accounts coa
        WHERE coa.parent_account_id = p_chart_of_account_id
    ),
    all_descendants AS (
        WITH RECURSIVE hierarchy AS (
            SELECT ca.id AS descendant_id, ca.parent_account_id AS ancestor_parent_id
            FROM chart_of_accounts ca
            WHERE ca.parent_account_id IN (SELECT child_id FROM direct_children)

            UNION ALL

            SELECT coa.id AS descendant_id, coa.parent_account_id AS ancestor_parent_id
            FROM chart_of_accounts coa
            INNER JOIN hierarchy h ON coa.parent_account_id = h.descendant_id
        )
        SELECT descendant_id, ancestor_parent_id FROM hierarchy
    ),
    years AS (
        SELECT p_fin_year_id AS year
        UNION ALL
        SELECT (p_fin_year_id - 1) AS year
    ),
    all_accounts AS (
        SELECT 
            dc.child_id AS account_id, 
            dc.child_name AS account_name, 
            dc.direct_parent_id AS parent_account_id, 
            dc.account_type_id, 
            y.year,
            dc.child_id AS summation_base_id
        FROM direct_children dc
        CROSS JOIN years y

        UNION ALL

        SELECT 
            ad.descendant_id AS account_id, 
            dc.child_name AS account_name, 
            dc.direct_parent_id AS parent_account_id, 
            dc.account_type_id, 
            y.year,
            dc.child_id AS summation_base_id
        FROM direct_children dc
        JOIN all_descendants ad ON dc.child_id = ad.ancestor_parent_id
        CROSS JOIN years y
    )
    SELECT 
        aa.summation_base_id AS account_id,
        aa.account_name,
        aa.parent_account_id,
        at.name AS account_type,
        aa.year,

        -- Monthly values, ensuring correct year filtering
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 4 THEN je.amount ELSE 0 END), 0) AS apr,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 5 THEN je.amount ELSE 0 END), 0) AS may,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 6 THEN je.amount ELSE 0 END), 0) AS jun,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 7 THEN je.amount ELSE 0 END), 0) AS jul,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 8 THEN je.amount ELSE 0 END), 0) AS aug,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 9 THEN je.amount ELSE 0 END), 0) AS sep,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 10 THEN je.amount ELSE 0 END), 0) AS oct,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 11 THEN je.amount ELSE 0 END), 0) AS nov,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 12 THEN je.amount ELSE 0 END), 0) AS "dec",
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 1 THEN je.amount ELSE 0 END), 0) AS jan,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 2 THEN je.amount ELSE 0 END), 0) AS feb,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date AND EXTRACT(MONTH FROM je.transaction_date) = 3 THEN je.amount ELSE 0 END), 0) AS mar,

        -- Totals for each year
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date THEN je.amount ELSE 0 END), 0) AS total_current_year,
        COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_prev_start_date AND v_prev_end_date THEN je.amount ELSE 0 END), 0) AS total_last_year,

        -- Difference calculation
        (COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_start_date AND v_end_date THEN je.amount ELSE 0 END), 0) - 
         COALESCE(SUM(CASE WHEN je.transaction_date BETWEEN v_prev_start_date AND v_prev_end_date THEN je.amount ELSE 0 END), 0)) 
        AS difference

    FROM all_accounts aa
    LEFT JOIN journal_entries je 
        ON je.account_id = aa.account_id 
        AND (je.transaction_date BETWEEN v_start_date AND v_end_date OR 
             je.transaction_date BETWEEN v_prev_start_date AND v_prev_end_date)
    LEFT JOIN account_types at ON at.id = aa.account_type_id
    GROUP BY aa.year, aa.summation_base_id, aa.account_name, aa.parent_account_id, at.name
    ORDER BY aa.summation_base_id, aa.year;

END;
$function$

-- Function: get_all_coa
CREATE OR REPLACE FUNCTION public.get_all_coa(p_organization_id uuid, p_finyear_id integer)
 RETURNS TABLE(id uuid, account_type text, account_number integer, name text, opening_balance numeric, level integer, order_sequence character varying, is_default_account boolean, schedule text)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH RECURSIVE coa_view AS (
        SELECT
            coa.id,
            act.name as account_type,
            coa.account_number::integer,
            coa.name,
            coa.parent_account_id,
            0 AS level,
            coa.account_number::text AS order_sequence,
            coa.is_default_account,
            NULL::text AS schedule
        FROM public.chart_of_accounts coa
        INNER JOIN public.account_types act ON coa.account_type_id = act.id
        WHERE coa.organization_id = p_organization_id  
          AND (coa.parent_account_id = '00000000-0000-0000-0000-000000000000' OR coa.parent_account_id IS NULL)
          AND coa.is_deleted = FALSE

        UNION ALL

        SELECT
            coa.id,
            act.name as account_type,
            coa.account_number::integer,
            coa.name,
            coa.parent_account_id,
            view.level + 1 AS level,
            view.order_sequence || '.' || coa.account_number::text AS order_sequence,
            coa.is_default_account,
            NULL::text AS schedule
        FROM public.chart_of_accounts coa
        INNER JOIN coa_view view ON view.id = coa.parent_account_id
        INNER JOIN public.account_types act ON coa.account_type_id = act.id
        WHERE coa.organization_id = p_organization_id  
          AND coa.is_deleted = FALSE
    ),
    balances AS (
        SELECT
            je.account_id,
            SUM(
                CASE WHEN je.entry_type = 'D' THEN je.amount 
                     ELSE -je.amount END
            ) AS balance
        FROM public.journal_entries je
        INNER JOIN public.transaction_headers th 
            ON th.id = je.transaction_id
        INNER JOIN public.companies c
            ON th.company_id = c.id
           AND c.organization_id = p_organization_id
        INNER JOIN public.finance_year fy  
            ON th.transaction_date BETWEEN fy.start_date AND fy.end_date
           AND fy.id = p_finyear_id
        WHERE th.is_deleted = FALSE
        GROUP BY je.account_id
    )
    SELECT
        view.id,
        view.account_type,
        view.account_number,
        LPAD('', view.level * 4, ' ') || view.name AS name,
        COALESCE(balances.balance, 0) AS opening_balance,
        view.level,
        view.order_sequence::character varying AS order_sequence,
        view.is_default_account,
        view.schedule
    FROM coa_view view
    LEFT JOIN balances ON balances.account_id = view.id
    ORDER BY view.order_sequence;
END;
$function$

-- Function: get_all_coa_with_pi
CREATE OR REPLACE FUNCTION public.get_all_coa_with_pi(p_organization_id uuid)
 RETURNS TABLE(id uuid, account_type text, account_number integer, name text, opening_balance numeric, level integer, order_sequence character varying, schedule text, parent_account_id uuid)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN query
    WITH RECURSIVE coa_view AS (   
        SELECT
            coa.id,
            act.name as account_type,
            coa.account_number::integer,
            coa.name,
            coa.parent_account_id,
            0 AS level,
            coa.account_number::text AS order_sequence,
            NULL::text AS schedule
        FROM 
            public.chart_of_accounts coa
        INNER JOIN
            public.account_types act ON coa.account_type_id = act.id
        WHERE
            coa.organization_id = p_organization_id  
            AND coa.parent_account_id = '00000000-0000-0000-0000-000000000000'
            AND coa.is_deleted = FALSE
        UNION ALL
        SELECT 
            coa.id,
            act.name as account_type,
            coa.account_number::integer,
            coa.name,
            coa.parent_account_id,
            view.level + 1 AS level,
            view.order_sequence || '.' || coa.account_number::text AS order_sequence,
            NULL::text AS schedule
        FROM 
            public.chart_of_accounts coa
        INNER JOIN 
            coa_view view ON view.id = coa.parent_account_id
        INNER JOIN
            public.account_types act ON coa.account_type_id = act.id
        WHERE
            coa.organization_id = p_organization_id  
            AND coa.is_deleted = FALSE
    )
    SELECT 
        view.id,
        view.account_type,
        view.account_number,
        LPAD('', view.level * 4, ' ') || view.name AS name,
        0::numeric AS opening_balance,
        view.level,
        view.order_sequence::character varying AS order_sequence,
        view.schedule,
        view.parent_account_id
    FROM 
        coa_view view
    ORDER BY 
        view.order_sequence;
END;
$function$

-- Function: change_user_password
CREATE OR REPLACE FUNCTION public.change_user_password(p_user_name text, p_current_password text, p_new_password text, p_modified_by uuid)
 RETURNS boolean
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_user_id UUID;
BEGIN
    -- Step 1: verify current password
    SELECT id
    INTO v_user_id
    FROM users
    WHERE user_name = p_user_name
      AND is_deleted = false
      AND password_hash = crypt(p_current_password, password_hash);

    IF v_user_id IS NULL THEN
        RETURN FALSE;
    END IF;

    -- Step 2: update password
    UPDATE users
    SET password_hash = crypt(p_new_password, gen_salt('bf', 12)),
        modified_on_utc = NOW(),
        modified_by = p_modified_by
    WHERE id = v_user_id;

    RETURN TRUE;
END;
$function$

-- Function: get_coa_opening_balance
CREATE OR REPLACE FUNCTION public.get_coa_opening_balance(p_coa_id uuid, p_finyear_id integer)
 RETURNS TABLE(transaction_date timestamp without time zone, coa_id uuid, coa_name text, description text, debit numeric, credit numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_year_text text;
BEGIN
    -- Fetch the year text for the given finance year id
    SELECT year INTO v_year_text FROM public.finance_year WHERE id = p_finyear_id;
    IF v_year_text IS NULL THEN
        RAISE EXCEPTION 'Finance year with id % not found!', p_finyear_id;
    END IF;

    RETURN QUERY
    SELECT
        th.transaction_date,
        th.document_id AS coa_id,
        coa.name AS coa_name,
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) AS debit,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) AS credit
    FROM public.transaction_headers th
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts coa ON th.document_id = coa.id
    WHERE th.document_id = p_coa_id
      AND je.account_id = th.document_id
      AND th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'
    ORDER BY th.transaction_date;
END;
$function$

-- Function: get_cash_flow
CREATE OR REPLACE FUNCTION public.get_cash_flow()
 RETURNS TABLE(transaction_date date, account_number text, name text, net_cash_flow numeric)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    SELECT 
        je.transaction_date,
        coa.account_number,
        coa.name,
        SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE -je.amount END) AS net_cash_flow
    FROM 
        public.journal_entries je
    JOIN 
        public.chart_of_accounts coa ON je.account_id = coa.id
    WHERE 
        coa.account_type_id = 1  -- Current Assets, focusing on cash accounts
        AND je.is_deleted = false
    GROUP BY 
        je.transaction_date, coa.account_number, coa.name
    ORDER BY 
      coa.account_number,  je.transaction_date ;
END;
$function$

-- Function: get_cash_flow
CREATE OR REPLACE FUNCTION public.get_cash_flow(p_company_id uuid)
 RETURNS TABLE(transaction_date date, account_number text, name text, net_cash_flow numeric)
 LANGUAGE plpgsql
AS $function$

                BEGIN
                    RETURN QUERY
                    SELECT 
                        je.transaction_date::date,
                        coa.account_number,
                        coa.name,
                        SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE -je.amount END) AS net_cash_flow
                    FROM 
                        public.journal_entries je
                    JOIN 
                        public.chart_of_accounts coa ON je.account_id = coa.id
                    JOIN
                        public.transaction_headers th ON je.transaction_id = th.id
                    WHERE 
                        coa.account_type_id = 1  -- Current Assets, focusing on cash accounts
                        AND je.is_deleted = false
                        AND th.company_id = p_company_id
                    GROUP BY 
                        je.transaction_date, coa.account_number, coa.name
                    ORDER BY 
                       coa.account_number, je.transaction_date  ;
                END;
                
$function$

-- Function: get_customer_opening_balance
CREATE OR REPLACE FUNCTION public.get_customer_opening_balance(p_customer_id uuid, p_finyear_id integer)
 RETURNS TABLE(transaction_date timestamp without time zone, customer_id uuid, customer_name text, description text, debit numeric, credit numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_year_text text;
BEGIN
    -- Fetch the year text for the given finance year id
    SELECT year INTO v_year_text FROM public.finance_year WHERE id = p_finyear_id;
    IF v_year_text IS NULL THEN
        RAISE EXCEPTION 'Finance year with id % not found!', p_finyear_id;
    END IF;

    RETURN QUERY
    SELECT
        th.transaction_date,
        th.customer_id,
        c.name::text AS customer_name,  -- explicit cast here!
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) AS debit,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) AS credit
    FROM public.transaction_headers th
    JOIN public.customers c ON th.customer_id = c.id
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts sd ON sd.name ILIKE '%Sundry Debtors%'
    WHERE th.customer_id = p_customer_id
      AND je.account_id = sd.id
      AND th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'
    ORDER BY th.transaction_date;
END;
$function$

-- Function: get_dashboard_totals_by_company_id
CREATE OR REPLACE FUNCTION public.get_dashboard_totals_by_company_id(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(income_total numeric, expense_total numeric, pending_dues_total numeric, pending_payments_total numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_organization_id UUID;
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_finance_year TEXT;
BEGIN
    -- Fetch organization ID
    SELECT organization_id INTO v_organization_id
    FROM public.companies
    WHERE id = p_company_id;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid company ID: %', p_company_id;
    END IF;

    -- Fetch financial year details
    SELECT start_date, end_date, year INTO v_financial_year_start, v_financial_year_end, v_finance_year
    FROM public.finance_year
    WHERE id = p_finance_year_id;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid finance year ID: %', p_finance_year_id;
    END IF;

    -- Calculate totals
    RETURN QUERY
    SELECT 
        -- Income Total
        ROUND(
            (
                SELECT COALESCE(SUM(je.amount), 0)
                FROM public.journal_entries je
                INNER JOIN public.chart_of_accounts ca ON je.account_id = ca.id
                INNER JOIN public.account_types at ON ca.account_type_id = at.id
                INNER JOIN public.account_categories ac ON at.account_category_id = ac.id
                INNER JOIN public.transaction_headers tr ON je.transaction_id = tr.id
                WHERE ac.id = 4 
                AND tr.company_id = p_company_id
                AND ca.organization_id = v_organization_id
                AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
                AND je.is_deleted = FALSE
            ), 2
        ) AS income_total,

        -- Expense Total
        ROUND(
            (
                SELECT COALESCE(SUM(je.amount), 0)
                FROM public.journal_entries je
                INNER JOIN public.chart_of_accounts ca ON je.account_id = ca.id
                INNER JOIN public.account_types at ON ca.account_type_id = at.id
                INNER JOIN public.account_categories ac ON at.account_category_id = ac.id
                INNER JOIN public.transaction_headers tr ON je.transaction_id = tr.id
                WHERE ac.id = 5 
                AND tr.company_id = p_company_id
                AND ca.organization_id = v_organization_id
                AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
                AND je.is_deleted = FALSE
            ), 2
        ) AS expense_total,

       ROUND(
    (
        SELECT
            COALESCE(SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END), 0) -
            COALESCE(SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END), 0)
        FROM public.journal_entries je
        INNER JOIN public.chart_of_accounts ca ON je.account_id = ca.id
        INNER JOIN public.account_types at ON ca.account_type_id = at.id
        INNER JOIN public.account_categories ac ON at.account_category_id = ac.id
        INNER JOIN public.transaction_headers tr ON je.transaction_id = tr.id
        WHERE at.name IN ('Accounts Receivable', 'Current Assets') -- Filter specifically for receivables
        AND tr.company_id = p_company_id
        AND ca.organization_id = v_organization_id
        AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        AND je.is_deleted = FALSE
    ), 2
) AS pending_dues_total,

        -- Pending Payments Total
ROUND(
    (
        SELECT COALESCE(SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END), 0) -
               COALESCE(SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END), 0)
        FROM public.journal_entries je
        INNER JOIN public.chart_of_accounts ca ON je.account_id = ca.id
        INNER JOIN public.account_types at ON ca.account_type_id = at.id
        INNER JOIN public.transaction_headers tr ON je.transaction_id = tr.id
        WHERE ca.account_type_id IN (
            SELECT id
            FROM public.get_account_type_hierarchy(2)
        )
        AND tr.company_id = p_company_id
        AND ca.organization_id = v_organization_id
        AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
        AND je.is_deleted = FALSE
        AND je.entry_type IN ('C', 'D') -- Ensure only valid entry types are included
    ), 2
) AS pending_payments_total


;

END;
$function$

-- Function: get_dashboard_totals_test
CREATE OR REPLACE FUNCTION public.get_dashboard_totals_test(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(income_total numeric, expense_total numeric, pending_dues_total numeric, pending_payments_total numeric, prev_income_total numeric, prev_expense_total numeric, prev_pending_dues_total numeric, prev_pending_payments_total numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_organization_id UUID;
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_prev_financial_year_start DATE;
    v_prev_financial_year_end DATE;
    v_finance_year INTEGER;
    v_today DATE := CURRENT_DATE;
BEGIN
    -- Fetch organization ID
    SELECT organization_id INTO v_organization_id
    FROM public.companies
    WHERE id = p_company_id;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid company ID: %', p_company_id;
    END IF;

    -- Get financial year integer from 'YYYY-YY'
    SELECT LEFT(year, 4)::INTEGER INTO v_finance_year
    FROM public.finance_year
    WHERE id = p_finance_year_id
    LIMIT 1;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid finance year ID: %', p_finance_year_id;
    END IF;

    -- Define financial year range
    v_financial_year_start := MAKE_DATE(v_finance_year, 4, 1);
    v_financial_year_end := MAKE_DATE(v_finance_year + 1, 3, 31);

    -- Define previous financial year range
    v_prev_financial_year_start := MAKE_DATE(v_finance_year - 1, 4, 1);
    v_prev_financial_year_end := MAKE_DATE(v_finance_year, 3, 31);

    -- Adjust financial year ends if the year is ongoing
    IF v_today < v_financial_year_end THEN
        v_financial_year_end := v_today;
    END IF;

    IF v_today < v_prev_financial_year_end THEN
        v_prev_financial_year_end := v_today - INTERVAL '1 year';
    END IF;

    -- Align both end dates to same day/month by limiting to shorter period
    v_financial_year_end := LEAST(v_financial_year_end, v_prev_financial_year_end + INTERVAL '1 year');
    v_prev_financial_year_end := v_financial_year_end - INTERVAL '1 year';

    -- Return calculated data
    RETURN QUERY
    SELECT 
        -- Current Year Income
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 4
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Current Year Expense
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 5
			  and tr.transaction_source_type  = 2
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Pending Dues
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE at.name IN ('Accounts Receivable', 'Current Assets')
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Pending Payments
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ca.account_type_id IN (SELECT id FROM get_account_type_hierarchy(2))
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Income
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 4
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Expense
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 5
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Pending Dues
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE at.name IN ('Accounts Receivable', 'Current Assets')
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Pending Payments
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ca.account_type_id IN (SELECT id FROM get_account_type_hierarchy(2))
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2);
END;
$function$

-- Function: get_dashboard_totals_with_previous_year_comparison
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_dashboard_totals_with_previous_year_comparison(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(income_total numeric, expense_total numeric, pending_dues_total numeric, pending_payments_total numeric, prev_income_total numeric, prev_expense_total numeric, prev_pending_dues_total numeric, prev_pending_payments_total numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_organization_id UUID;
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_prev_financial_year_start DATE;
    v_prev_financial_year_end DATE;
    v_finance_year INTEGER;
    v_today DATE := CURRENT_DATE;
BEGIN
    -- Fetch organization ID
    SELECT organization_id INTO v_organization_id
    FROM public.companies
    WHERE id = p_company_id;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid company ID: %', p_company_id;
    END IF;

    -- Get financial year integer from 'YYYY-YY'
    SELECT LEFT(year, 4)::INTEGER INTO v_finance_year
    FROM public.finance_year
    WHERE id = p_finance_year_id
    LIMIT 1;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid finance year ID: %', p_finance_year_id;
    END IF;

    -- Define financial year range
    v_financial_year_start := MAKE_DATE(v_finance_year, 4, 1);
    v_financial_year_end := MAKE_DATE(v_finance_year + 1, 3, 31);

    -- Define previous financial year range
    v_prev_financial_year_start := MAKE_DATE(v_finance_year - 1, 4, 1);
    v_prev_financial_year_end := MAKE_DATE(v_finance_year, 3, 31);

    -- Adjust financial year ends if the year is ongoing
    IF v_today < v_financial_year_end THEN
        v_financial_year_end := v_today;
    END IF;

    IF v_today < v_prev_financial_year_end THEN
        v_prev_financial_year_end := v_today - INTERVAL '1 year';
    END IF;

    -- Align both end dates to same day/month by limiting to shorter period
    v_financial_year_end := LEAST(v_financial_year_end, v_prev_financial_year_end + INTERVAL '1 year');
    v_prev_financial_year_end := v_financial_year_end - INTERVAL '1 year';

    -- Return calculated data
    RETURN QUERY
    SELECT 
        -- Current Year Income
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 4
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Current Year Expense
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 5
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Pending Dues
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE at.name IN ('Accounts Receivable', 'Current Assets')
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Pending Payments
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ca.account_type_id IN (SELECT id FROM get_account_type_hierarchy(2))
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Income
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 4
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Expense
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 5
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Pending Dues
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE at.name IN ('Accounts Receivable', 'Current Assets')
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Pending Payments
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ca.account_type_id IN (SELECT id FROM get_account_type_hierarchy(2))
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2);
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_dashboard_totals_with_previous_year_comparison(p_company_id uuid, p_finance_year_id integer)
 RETURNS TABLE(income_total numeric, expense_total numeric, pending_dues_total numeric, pending_payments_total numeric, prev_income_total numeric, prev_expense_total numeric, prev_pending_dues_total numeric, prev_pending_payments_total numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_organization_id UUID;
    v_financial_year_start DATE;
    v_financial_year_end DATE;
    v_prev_financial_year_start DATE;
    v_prev_financial_year_end DATE;
    v_finance_year INTEGER;
    v_today DATE := CURRENT_DATE;
BEGIN
    -- Fetch organization ID
    SELECT organization_id INTO v_organization_id
    FROM public.companies
    WHERE id = p_company_id;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid company ID: %', p_company_id;
    END IF;

    -- Get financial year integer from 'YYYY-YY'
    SELECT LEFT(year, 4)::INTEGER INTO v_finance_year
    FROM public.finance_year
    WHERE id = p_finance_year_id
    LIMIT 1;

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Invalid finance year ID: %', p_finance_year_id;
    END IF;

    -- Define financial year range
    v_financial_year_start := MAKE_DATE(v_finance_year, 4, 1);
    v_financial_year_end := MAKE_DATE(v_finance_year + 1, 3, 31);

    -- Define previous financial year range
    v_prev_financial_year_start := MAKE_DATE(v_finance_year - 1, 4, 1);
    v_prev_financial_year_end := MAKE_DATE(v_finance_year, 3, 31);

    -- Adjust financial year ends if the year is ongoing
    IF v_today < v_financial_year_end THEN
        v_financial_year_end := v_today;
    END IF;

    IF v_today < v_prev_financial_year_end THEN
        v_prev_financial_year_end := v_today - INTERVAL '1 year';
    END IF;

    -- Align both end dates to same day/month by limiting to shorter period
    v_financial_year_end := LEAST(v_financial_year_end, v_prev_financial_year_end + INTERVAL '1 year');
    v_prev_financial_year_end := v_financial_year_end - INTERVAL '1 year';

    -- Return calculated data
    RETURN QUERY
    SELECT 
        -- Current Year Income
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 4
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Current Year Expense
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 5
			  AND tr.transaction_source_type  = 2
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Pending Dues
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE at.name IN ('Accounts Receivable', 'Current Assets')
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Pending Payments
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ca.account_type_id IN (SELECT id FROM get_account_type_hierarchy(2))
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Income
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 4
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Expense
        ROUND(COALESCE((
            SELECT SUM(je.amount)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN account_categories ac ON at.account_category_id = ac.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ac.id = 5
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Pending Dues
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE at.name IN ('Accounts Receivable', 'Current Assets')
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2),

        -- Previous Year Pending Payments
        ROUND(COALESCE((
            SELECT SUM(CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END) -
                   SUM(CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END)
            FROM journal_entries je
            JOIN chart_of_accounts ca ON je.account_id = ca.id
            JOIN account_types at ON ca.account_type_id = at.id
            JOIN transaction_headers tr ON je.transaction_id = tr.id
            WHERE ca.account_type_id IN (SELECT id FROM get_account_type_hierarchy(2))
              AND tr.company_id = p_company_id
              AND ca.organization_id = v_organization_id
              AND je.transaction_date BETWEEN v_prev_financial_year_start AND v_prev_financial_year_end
              AND je.is_deleted = FALSE
        ), 0), 2);
END;
$function$

-- Function: get_employee_opening_balance
CREATE OR REPLACE FUNCTION public.get_employee_opening_balance(p_employee_id uuid, p_finyear_id integer)
 RETURNS TABLE(transaction_date timestamp without time zone, employee_id uuid, employee_name text, description text, debit numeric, credit numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_year_text text;
BEGIN
    -- Fetch the year text for the given finance year id
    SELECT year INTO v_year_text FROM public.finance_year WHERE id = p_finyear_id;
    IF v_year_text IS NULL THEN
        RAISE EXCEPTION 'Finance year with id % not found!', p_finyear_id;
    END IF;

    RETURN QUERY
    SELECT
        th.transaction_date,
        th.employee_id,
        (e.first_name || ' ' || e.last_name) AS employee_name,
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) AS debit,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) AS credit
    FROM public.transaction_headers th
    JOIN public.employees e ON th.employee_id = e.id
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts sp ON sp.name ILIKE '%Salary Payable%'
    WHERE th.employee_id = p_employee_id
      AND je.account_id = sp.id
      AND th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'
    ORDER BY th.transaction_date;
END;
$function$

-- Function: get_expense_overview
CREATE OR REPLACE FUNCTION public.get_expense_overview(p_company_id uuid, p_period_type integer, p_finance_id integer)
 RETURNS TABLE(period text, year numeric, account_name text, total_expense numeric)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_financial_year_start date;
    v_financial_year_end date;
    v_finance_year text;
    v_organization_id uuid;

    -- Define constants for period types
    CONST_MONTHLY CONSTANT INTEGER := 1;
    CONST_QUARTERLY CONSTANT INTEGER := 2;
    CONST_HALF_YEARLY CONSTANT INTEGER := 3;
    CONST_YEARLY CONSTANT INTEGER := 4;
BEGIN
    -- Step 1: Fetch the organization ID based on the company ID
    SELECT organization_id INTO v_organization_id
    FROM public.companies
    WHERE id = p_company_id;

    -- Step 2: Get financial year boundaries
    SELECT fy.start_date, fy.end_date, fy.year INTO v_financial_year_start, v_financial_year_end, v_finance_year
    FROM public.finance_year fy
    WHERE id = p_finance_id;

    -- Check the period type and execute the appropriate logic
    IF p_period_type = CONST_MONTHLY THEN
        RETURN QUERY
        WITH RECURSIVE AccountHierarchy AS (
            -- Base case: Select root accounts (expense accounts)
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            WHERE 
                coa.account_type_id = 5 -- Expense accounts
                AND coa.organization_id = v_organization_id

            UNION ALL

            -- Recursive case: Select child accounts under the root accounts
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            INNER JOIN 
                AccountHierarchy ah ON coa.parent_account_id = ah.account_id
        ),
        months AS (
            SELECT 
                TO_CHAR(months.m, 'Mon') AS period, 
                EXTRACT(YEAR FROM months.m) AS extracted_year,  
                EXTRACT(MONTH FROM months.m) AS month_num
            FROM 
                generate_series(v_financial_year_start, v_financial_year_end, '1 month'::interval) AS months(m)
        )
        SELECT 
            months.period,
            months.extracted_year AS year,
            ah.account_name,  
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM 
            months
        INNER JOIN journal_entries je 
            ON EXTRACT(MONTH FROM je.transaction_date) = months.month_num 
            AND EXTRACT(YEAR FROM je.transaction_date) = months.extracted_year
        INNER JOIN transaction_headers tr 
            ON je.transaction_id = tr.id 
            AND tr.company_id = p_company_id -- Ensure filtering by company_id
        INNER JOIN AccountHierarchy ah 
            ON je.account_id = ah.account_id
        WHERE 
            je.entry_type = 'D' -- Only debits are considered expenses
            AND je.is_deleted = FALSE -- Filter non-deleted entries
        GROUP BY 
            months.period, months.extracted_year, months.month_num, ah.account_name
        ORDER BY 
            months.extracted_year, months.month_num, ah.account_name;

    ELSIF p_period_type = CONST_QUARTERLY THEN
        RETURN QUERY
        WITH RECURSIVE AccountHierarchy AS (
            -- Base case: Select root accounts (expense accounts)
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            WHERE 
                coa.account_type_id = 5 -- Expense accounts
                AND coa.organization_id = v_organization_id

            UNION ALL

            -- Recursive case: Select child accounts under the root accounts
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            INNER JOIN 
                AccountHierarchy ah ON coa.parent_account_id = ah.account_id
        ),
        quarters AS (
            SELECT 
                'Q1' AS period, 1 AS quarter_num, EXTRACT(YEAR FROM v_financial_year_start) AS extracted_year,
                v_financial_year_start AS start_date, v_financial_year_start + interval '2 month' AS end_date
            UNION ALL
            SELECT 
                'Q2' AS period, 2 AS quarter_num, EXTRACT(YEAR FROM v_financial_year_start) AS extracted_year,
                v_financial_year_start + interval '3 month' AS start_date, v_financial_year_start + interval '5 month' AS end_date
            UNION ALL
            SELECT 
                'Q3' AS period, 3 AS quarter_num, EXTRACT(YEAR FROM v_financial_year_start) AS extracted_year,
                v_financial_year_start + interval '6 month' AS start_date, v_financial_year_start + interval '8 month' AS end_date
            UNION ALL
            SELECT 
                'Q4' AS period, 4 AS quarter_num, EXTRACT(YEAR FROM v_financial_year_start) + 1 AS extracted_year,
                v_financial_year_start + interval '9 month' AS start_date, v_financial_year_end AS end_date
        )
        SELECT 
            quarters.period,
            quarters.extracted_year AS year,
            ah.account_name,  
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM 
            quarters
        LEFT JOIN journal_entries je 
            ON je.transaction_date BETWEEN quarters.start_date AND quarters.end_date 
        LEFT JOIN transaction_headers tr 
            ON je.transaction_id = tr.id 
            AND tr.company_id = p_company_id -- Ensure filtering by company_id
        INNER JOIN AccountHierarchy ah 
            ON je.account_id = ah.account_id
        WHERE 
            je.entry_type = 'D' -- Only debits are considered expenses
            AND je.is_deleted = FALSE -- Filter non-deleted entries
        GROUP BY 
            quarters.period, quarters.extracted_year, quarters.quarter_num, ah.account_name
        ORDER BY 
            quarters.extracted_year, quarters.quarter_num, ah.account_name;

    -- Repeat similar adjustments for Half-Yearly and Yearly periods.
	    ELSIF p_period_type = CONST_HALF_YEARLY THEN
        RETURN QUERY
        WITH RECURSIVE AccountHierarchy AS (
            -- Base case: Select root accounts (expense accounts)
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            WHERE 
                coa.account_type_id = 5 -- Expense accounts
                AND coa.organization_id = v_organization_id

            UNION ALL

            -- Recursive case: Select child accounts under the root accounts
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            INNER JOIN 
                AccountHierarchy ah ON coa.parent_account_id = ah.account_id
        ),
        half_years AS (
            SELECT 
                'H1' AS period, 
                1 AS half_year_num, 
                EXTRACT(YEAR FROM v_financial_year_start) AS extracted_year,
                v_financial_year_start AS start_date, 
                v_financial_year_start + interval '5 month' AS end_date
            UNION ALL
            SELECT 
                'H2' AS period, 
                2 AS half_year_num, 
                EXTRACT(YEAR FROM v_financial_year_start) AS extracted_year,
                v_financial_year_start + interval '6 month' AS start_date, 
                v_financial_year_end AS end_date
        )
        SELECT 
            half_years.period,
            half_years.extracted_year AS year,
            ah.account_name,  
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM 
            half_years
        LEFT JOIN journal_entries je 
            ON je.transaction_date BETWEEN half_years.start_date AND half_years.end_date
        LEFT JOIN transaction_headers tr 
            ON je.transaction_id = tr.id 
            AND tr.company_id = p_company_id -- Ensure filtering by company_id
        INNER JOIN AccountHierarchy ah 
            ON je.account_id = ah.account_id
        WHERE 
            je.entry_type = 'D' -- Only debits are considered expenses
            AND je.is_deleted = FALSE -- Filter non-deleted entries
        GROUP BY 
            half_years.period, half_years.extracted_year, half_years.half_year_num, ah.account_name
        ORDER BY 
            half_years.extracted_year, half_years.half_year_num, ah.account_name;
    ELSIF p_period_type = CONST_YEARLY THEN
        RETURN QUERY
        WITH RECURSIVE AccountHierarchy AS (
            -- Base case: Select root accounts (expense accounts)
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            WHERE 
                coa.account_type_id = 5 -- Expense accounts
                AND coa.organization_id = v_organization_id

            UNION ALL

            -- Recursive case: Select child accounts under the root accounts
            SELECT 
                coa.id AS account_id,
                coa.name AS account_name,
                coa.account_number,
                coa.parent_account_id
            FROM 
                public.chart_of_accounts coa
            INNER JOIN 
                AccountHierarchy ah ON coa.parent_account_id = ah.account_id
        )
        SELECT 
            'Year' AS period,
            EXTRACT(YEAR FROM v_financial_year_start) AS year,
            ah.account_name,  
            COALESCE(SUM(je.amount), 0) AS total_expense
        FROM 
            journal_entries je
        LEFT JOIN transaction_headers tr 
            ON je.transaction_id = tr.id 
            AND tr.company_id = p_company_id -- Ensure filtering by company_id
        INNER JOIN AccountHierarchy ah 
            ON je.account_id = ah.account_id
        WHERE 
            je.transaction_date BETWEEN v_financial_year_start AND v_financial_year_end
            AND je.entry_type = 'D' -- Only debits are considered expenses
            AND je.is_deleted = FALSE -- Filter non-deleted entries
        GROUP BY 
            year, ah.account_name
        ORDER BY 
            year, ah.account_name;

    END IF;
END;
$function$

-- Function: get_full_account_hierarchy_overview
CREATE OR REPLACE FUNCTION public.get_full_account_hierarchy_overview(p_company_id uuid, p_fin_year_id integer)
 RETURNS TABLE(account_id uuid, account_name text, parent_account_id uuid, hierarchy_path text[], financial_year integer, apr numeric, may numeric, jun numeric, jul numeric, aug numeric, sep numeric, oct numeric, nov numeric, "dec" numeric, jan numeric, feb numeric, mar numeric, total_sum numeric, difference numeric)
 LANGUAGE plpgsql
AS $function$
#variable_conflict use_column
DECLARE 
    v_current_year INTEGER := p_fin_year_id;
    v_previous_year INTEGER := p_fin_year_id - 1;
    v_organization_id UUID;
BEGIN
    SELECT c.organization_id INTO v_organization_id 
    FROM public.companies c
    WHERE c.id = p_company_id;

    RETURN QUERY
    WITH RECURSIVE account_with_path AS (
        -- This is a much safer way to build the path
        SELECT
            ca.id,
            ca.name,
            ca.parent_account_id,
            -- If parent is missing or is self, start a new path. Otherwise, build the path.
            COALESCE(p.name, '') || '/' || ca.name AS path_str
        FROM chart_of_accounts ca
        LEFT JOIN chart_of_accounts p ON ca.parent_account_id = p.id AND ca.parent_account_id != ca.id
        WHERE ca.organization_id = v_organization_id
    ),
    financial_years AS (
        SELECT id AS fin_year_id, start_date, end_date
        FROM finance_year
        WHERE id IN (v_previous_year, v_current_year)
    ),
    aggregated_data AS (
        SELECT
            awp.id, awp.name, awp.parent_account_id, 
            -- Convert the path string to an array for AG Grid
            string_to_array(ltrim(awp.path_str, '/'), '/') AS hierarchy_path,
            fy.fin_year_id,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 4 THEN 1 ELSE 0 END), 0) AS apr,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 5 THEN 1 ELSE 0 END), 0) AS may,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 6 THEN 1 ELSE 0 END), 0) AS jun,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 7 THEN 1 ELSE 0 END), 0) AS jul,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 8 THEN 1 ELSE 0 END), 0) AS aug,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 9 THEN 1 ELSE 0 END), 0) AS sep,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 10 THEN 1 ELSE 0 END), 0) AS oct,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 11 THEN 1 ELSE 0 END), 0) AS nov,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 12 THEN 1 ELSE 0 END), 0) AS "dec",
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 1 THEN 1 ELSE 0 END), 0) AS jan,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 2 THEN 1 ELSE 0 END), 0) AS feb,
            COALESCE(SUM(je.amount * CASE WHEN EXTRACT(MONTH FROM je.transaction_date) = 3 THEN 1 ELSE 0 END), 0) AS mar,
            COALESCE(SUM(je.amount), 0) AS total_sum
        FROM account_with_path awp
        CROSS JOIN financial_years fy
        LEFT JOIN journal_entries je ON je.account_id = awp.id AND je.transaction_date BETWEEN fy.start_date AND fy.end_date
        LEFT JOIN transaction_headers th ON th.id = je.transaction_id AND th.company_id = p_company_id
        WHERE (th.transaction_source_type IS NULL OR th.transaction_source_type != 13)
        GROUP BY awp.id, awp.name, awp.parent_account_id, awp.path_str, fy.fin_year_id
    )
    SELECT
        a1.id, a1.name, a1.parent_account_id, a1.hierarchy_path, a1.fin_year_id,
        a1.apr, a1.may, a1.jun, a1.jul, a1.aug, a1.sep, a1.oct, a1.nov, a1."dec",
        a1.jan, a1.feb, a1.mar,
        a1.total_sum,
        (COALESCE(a1.total_sum, 0) - COALESCE(a2.total_sum, 0)) AS difference
    FROM aggregated_data a1
    LEFT JOIN aggregated_data a2 ON a1.id = a2.id AND a1.fin_year_id = v_current_year AND a2.fin_year_id = v_previous_year
    ORDER BY a1.hierarchy_path, a1.fin_year_id;
END;
$function$

-- Function: get_n_years_expenses
CREATE OR REPLACE FUNCTION public.get_n_years_expenses(p_company_id uuid, p_fin_year_ids integer[])
 RETURNS TABLE(account_id uuid, account_name text, finance_year_id integer, finance_year_label text, month_number integer, month_label text, amount numeric)
 LANGUAGE plpgsql
 STABLE PARALLEL SAFE
AS $function$
DECLARE
    months_arr TEXT[] := ARRAY['Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec','Jan','Feb','Mar'];
    yrec RECORD;
    m INT;
    month_start DATE;
    month_end DATE;
BEGIN
    FOR yrec IN
        SELECT
            fy.id,
            fy.start_date,
            fy.end_date,
            CONCAT(EXTRACT(YEAR FROM fy.start_date), '-', RIGHT(TO_CHAR(fy.end_date, 'YYYY'), 2)) AS label
        FROM public.finance_year fy
        WHERE fy.id = ANY(p_fin_year_ids)
        ORDER BY fy.start_date
    LOOP
        FOR m IN 1..12 LOOP
            month_start := yrec.start_date + ((m - 1) * INTERVAL '1 month');
            month_end := (month_start + INTERVAL '1 month' - INTERVAL '1 day')::DATE;

            RETURN QUERY
            WITH RECURSIVE AccountHierarchy AS (
                SELECT coa.id, coa.name, coa.parent_account_id
                FROM public.chart_of_accounts coa
                WHERE coa.account_type_id = 5
                UNION ALL
                SELECT coa.id, coa.name, coa.parent_account_id
                FROM public.chart_of_accounts coa
                INNER JOIN AccountHierarchy ah ON coa.parent_account_id = ah.id
            )
            SELECT
                ah.id AS account_id,
                ah.name AS account_name,
                yrec.id AS finance_year_id,
                yrec.label AS finance_year_label,
                m AS month_number,
                months_arr[m] AS month_label,
                COALESCE(SUM(je.amount), 0) AS amount
            FROM AccountHierarchy ah
            LEFT JOIN public.journal_entries je
                ON je.account_id = ah.id
                AND je.transaction_date BETWEEN month_start AND month_end
                AND je.is_deleted = FALSE
            LEFT JOIN public.transaction_headers th
                ON je.transaction_id = th.id
                AND th.company_id = p_company_id
            GROUP BY ah.id, ah.name;
        END LOOP;
    END LOOP;
END;
$function$

-- Function: get_vendor_ledger
-- SOURCE
CREATE OR REPLACE FUNCTION public.get_vendor_ledger(p_vendor_id uuid, p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_id uuid, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_sundary_creditors_account_id UUID;
    v_vendor_advance_account_id UUID;
BEGIN
    SELECT 
        accounts_payable_account_id, 
        vendor_advance_account_id
    INTO 
        v_sundary_creditors_account_id, 
        v_vendor_advance_account_id
    FROM public.organization_accounts
    WHERE organization_id = p_organization_id
    LIMIT 1;

    RETURN QUERY
    WITH all_transactions AS (
        SELECT
            th.transaction_date::date,
            coa.id AS account_id,
            coa.name AS account_name,
            CASE WHEN je.entry_type = 'D' THEN je.amount ELSE 0 END AS debit,
            CASE WHEN je.entry_type = 'C' THEN je.amount ELSE 0 END AS credit,
            th.document_number,
            th.document_id,
            th.transaction_source_type,
            tst.sort_order,
            th.id AS transaction_id,
            je.id AS journal_entry_id
        FROM public.transaction_headers th
        JOIN public.journal_entries je ON th.id = je.transaction_id
        JOIN public.transaction_source_types tst ON th.transaction_source_type = tst.id
        JOIN public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE
            th.company_id = p_company_id
            AND th.vendor_id = p_vendor_id
            AND je.account_id IN (v_sundary_creditors_account_id, v_vendor_advance_account_id)
            AND th.transaction_date BETWEEN p_start_date AND p_end_date
            AND th.is_deleted = false
            AND je.is_deleted = false
    )
    SELECT
        at.transaction_date,
        at.account_id,
        at.account_name,
        at.debit,
        at.credit,
        SUM(at.debit - at.credit) OVER (
            ORDER BY 
                at.transaction_date, 
                at.sort_order, 
                at.transaction_id, 
                at.journal_entry_id
        ) AS balance,
        at.transaction_source_type,
        at.document_number,
        at.document_id
    FROM all_transactions AS at
    ORDER BY
        at.transaction_date,
        at.sort_order,
        at.transaction_id,
        at.journal_entry_id;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.get_vendor_ledger(p_vendor_id uuid, p_company_id uuid, p_organization_id uuid, p_start_date date, p_end_date date)
 RETURNS TABLE(transaction_date date, account_name text, debit numeric, credit numeric, balance numeric, transaction_source_type integer, document_number text, document_id uuid)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    WITH vendor_transactions AS (
        SELECT 
            th.transaction_date::date AS transaction_date,  
            coa.name AS account_name,
            CASE 
                WHEN je.entry_type = 'D' THEN je.amount 
                ELSE 0 
            END AS debit,
            CASE 
                WHEN je.entry_type = 'C' THEN je.amount 
                ELSE 0 
            END AS credit,
            th.company_id,
            th.vendor_id,
            th.transaction_source_type,   
            th.document_number,           
            th.document_id              
        FROM 
            public.transaction_headers th
        INNER JOIN 
            public.journal_entries je ON th.id = je.transaction_id  
        INNER JOIN 
            public.chart_of_accounts coa ON je.account_id = coa.id
        WHERE 
            th.vendor_id = p_vendor_id
            AND th.company_id = p_company_id
            AND coa.organization_id = p_organization_id
            AND th.is_deleted = false 
            AND je.is_deleted = false
            AND th.transaction_date >= p_start_date   
            AND th.transaction_date <= p_end_date     
    )
    SELECT 
        vt.transaction_date,
        vt.account_name,
        vt.debit,
        vt.credit,
        SUM(vt.debit - vt.credit) OVER (PARTITION BY vt.vendor_id ORDER BY vt.transaction_date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS balance,
        vt.transaction_source_type,   
        vt.document_number,           
        vt.document_id                
    FROM 
        vendor_transactions vt
    ORDER BY 
        vt.transaction_date;
END;
$function$

-- Function: get_year_wise_opening_balance
CREATE OR REPLACE FUNCTION public.get_year_wise_opening_balance(p_finyear_id integer)
 RETURNS TABLE(id bigint, transaction_date timestamp without time zone, entity_id uuid, entity_name text, description text, debit numeric, credit numeric, entity_type text)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_year_text text;
BEGIN
    -- Fetch the year text for the given finance year id
    SELECT fy.year INTO v_year_text FROM public.finance_year fy WHERE fy.id = p_finyear_id;
    IF v_year_text IS NULL THEN
        RAISE EXCEPTION 'Finance year with id % not found!', p_finyear_id;
    END IF;

    RETURN QUERY

    -- VENDORS
    SELECT
        th.id,
        th.transaction_date,
        th.vendor_id as entity_id,
        v.name::text as entity_name,
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) as debit,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) as credit,
        'Vendor' as entity_type
    FROM public.transaction_headers th
    JOIN public.vendors v ON th.vendor_id = v.id
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts sc ON je.account_id = sc.id AND sc.name ILIKE '%Sundry Creditors%'
    WHERE th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'

    UNION ALL

    -- CUSTOMERS
    SELECT
        th.id,
        th.transaction_date,
        th.customer_id as entity_id,
        c.name::text as entity_name,
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) as debit,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) as credit,
        'Customer' as entity_type
    FROM public.transaction_headers th
    JOIN public.customers c ON th.customer_id = c.id
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts sd ON je.account_id = sd.id AND sd.name ILIKE '%Sundry Debtors%'
    WHERE th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'

    UNION ALL

    -- EMPLOYEES
    SELECT
        th.id,
        th.transaction_date,
        th.employee_id as entity_id,
        e.first_name::text as entity_name,
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) as debit,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) as credit,
        'Employee' as entity_type
    FROM public.transaction_headers th
    JOIN public.employees e ON th.employee_id = e.id
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts sp ON je.account_id = sp.id AND sp.name ILIKE '%Salary Payable%'
    WHERE th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'

    UNION ALL

    -- COA ACCOUNTS (other than above)
    SELECT
        th.id,
        th.transaction_date,
        th.document_id as entity_id,
        coa.name::text as entity_name,
        th.description,
        COALESCE(CASE WHEN je.entry_type = 'D' THEN je.amount END, 0) as debit,
        COALESCE(CASE WHEN je.entry_type = 'C' THEN je.amount END, 0) as credit,
        'COA' as entity_type
    FROM public.transaction_headers th
    JOIN public.journal_entries je ON th.id = je.transaction_id
    JOIN public.chart_of_accounts coa ON th.document_id = coa.id AND je.account_id = th.document_id
    WHERE th.transaction_source_type = 13
      AND th.description LIKE 'Opening Balance for %' || v_year_text || '%'

    ORDER BY entity_name;

END;
$function$

-- Function: insert_multiple_transactions_and_journal_entries
-- SOURCE
CREATE OR REPLACE FUNCTION public.insert_multiple_transactions_and_journal_entries(p_transactions_data jsonb)
 RETURNS TABLE(transaction_id bigint, document_id uuid, reference text)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_transaction_id BIGINT;
    v_transaction_record JSONB;
    v_journal_entry JSONB;
    v_narration_id BIGINT;
    v_reference TEXT;
BEGIN
    -- Loop through each transaction in the input array
    FOR v_transaction_record IN SELECT * FROM jsonb_array_elements(p_transactions_data) 
    LOOP
        -- Insert into transaction_headers
        INSERT INTO public.transaction_headers (
            company_id,
            customer_id,
            vendor_id,
            employee_id,
            transaction_date,
            transaction_source_type,
            status_id,
            document_id,
            document_number,
            description,
            created_by,
            created_on_utc
        )
        VALUES(
            (v_transaction_record->>'company_id')::uuid,
            NULLIF((v_transaction_record->>'customer_id')::uuid, '00000000-0000-0000-0000-000000000000'),
            NULLIF((v_transaction_record->>'vendor_id')::uuid, '00000000-0000-0000-0000-000000000000'),
            NULLIF((v_transaction_record->>'employee_id')::uuid, '00000000-0000-0000-0000-000000000000'),
            (v_transaction_record->>'transaction_date')::date,
            (v_transaction_record->>'transaction_source_type')::integer,
            (v_transaction_record->>'status_id')::integer,
            (v_transaction_record->>'document_id')::uuid,
            v_transaction_record->>'document_number',
            v_transaction_record->>'description',
            (v_transaction_record->>'user_id')::uuid,
            CURRENT_TIMESTAMP
        )
        RETURNING id INTO v_transaction_id;

        -- ✅ Insert into payment_references if reference exists and not empty
        v_reference := NULLIF(TRIM(v_transaction_record->>'reference'), '');
        IF v_reference IS NOT NULL THEN
            INSERT INTO public.payment_references (
                transaction_id,
                reference
            )
            VALUES (
                v_transaction_id,
                v_reference
            );
        END IF;

        -- Loop through each journal entry associated with the transaction
        FOR v_journal_entry IN SELECT * FROM jsonb_array_elements(v_transaction_record->'journal_entries')
        LOOP 
            -- Insert narration first
            INSERT INTO public.journal_narrations (
                transaction_date,
                description_template_id,
                dynamic_data,
                created_by,
                created_on_utc
            )
            VALUES(
                (v_journal_entry->>'transaction_date')::timestamp,
                (v_journal_entry->>'description_template_id')::integer,
                COALESCE((v_journal_entry->>'dynamic_data'), ''),
                (v_transaction_record->>'user_id')::uuid,
                CURRENT_TIMESTAMP
            )
            RETURNING id INTO v_narration_id;

            -- Insert journal entry
            INSERT INTO public.journal_entries (
                transaction_id,
                account_id,
                transaction_date,
                amount,
                entry_type,
                entry_source_id,
                journal_narration_id
            )
            VALUES(
                v_transaction_id,
                (v_journal_entry->>'account_id')::uuid,
                (v_journal_entry->>'transaction_date')::date,
                (v_journal_entry->>'amount')::numeric,
                (v_journal_entry->>'entry_type')::char,
                (v_journal_entry->>'entry_source_id')::integer,
                v_narration_id
            );
        END LOOP;

        -- Return transaction ID, document ID, and reference for this transaction
        RETURN QUERY SELECT v_transaction_id, (v_transaction_record->>'document_id')::uuid, v_reference;
    END LOOP;

EXCEPTION
    WHEN OTHERS THEN
        RAISE EXCEPTION 'Error occurred: %', SQLERRM;
END;
$function$


-- TARGET
CREATE OR REPLACE FUNCTION public.insert_multiple_transactions_and_journal_entries(p_transactions_data jsonb)
 RETURNS TABLE(transaction_id bigint, document_id uuid)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_transaction_id BIGINT;
    v_transaction_record JSONB;
    v_journal_entry JSONB;
BEGIN
    -- Loop through each transaction in the input array
    FOR v_transaction_record IN SELECT * FROM jsonb_array_elements(p_transactions_data) 
    LOOP
        -- Insert into transaction_headers
        INSERT INTO public.transaction_headers (
            company_id,
            customer_id,
            vendor_id,
            employee_id,
            transaction_date,
            transaction_source_type,
            status_id,
            document_id,
            document_number,
            description,
            created_by,
            created_on_utc
        )
        VALUES(
            (v_transaction_record->>'company_id')::uuid,
            NULLIF((v_transaction_record->>'customer_id')::uuid, '00000000-0000-0000-0000-000000000000'),
            NULLIF((v_transaction_record->>'vendor_id')::uuid, '00000000-0000-0000-0000-000000000000'),
            NULLIF((v_transaction_record->>'employee_id')::uuid, '00000000-0000-0000-0000-000000000000'),
            (v_transaction_record->>'transaction_date')::date,
            (v_transaction_record->>'transaction_source_type')::integer,
            (v_transaction_record->>'status_id')::integer,
            (v_transaction_record->>'document_id')::uuid,
            v_transaction_record->>'document_number',
            v_transaction_record->>'description',
            (v_transaction_record->>'user_id')::uuid,
            CURRENT_TIMESTAMP
        )
        RETURNING id INTO v_transaction_id;

       

        -- Loop through each journal entry associated with the transaction
        FOR v_journal_entry IN SELECT * FROM jsonb_array_elements(v_transaction_record->'journal_entries')
        LOOP 
            INSERT INTO public.journal_entries (
                transaction_id,
                account_id,
                transaction_date,
                amount,
                entry_type,
                description_template_id,
                dynamic_data,
                entry_source_id
            )
            VALUES(
                v_transaction_id,
                (v_journal_entry->>'account_id')::uuid,
                (v_journal_entry->>'transaction_date')::date,
                (v_journal_entry->>'amount')::numeric,
                (v_journal_entry->>'entry_type')::char,
                (v_journal_entry->>'description_template_id')::integer,
                (v_journal_entry->>'dynamic_data')::jsonb,
                (v_journal_entry->>'entry_source_id')::integer
            );
        END LOOP;
		
		 -- Return transaction ID and document ID for this transaction
        RETURN QUERY SELECT v_transaction_id, (v_transaction_record->>'document_id')::uuid;
    END LOOP;
EXCEPTION
    -- Catch any error and raise an exception
    WHEN OTHERS THEN
        RAISE EXCEPTION 'Error occurred: %', SQLERRM;
END;
$function$

-- Function: assign_user_default_permissions
CREATE OR REPLACE FUNCTION public.assign_user_default_permissions(p_user_id uuid, p_role_id integer, p_organization_id uuid, p_created_by uuid DEFAULT NULL::uuid)
 RETURNS void
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_permission_count INT;
    v_existing_organization_user INT;
    v_existing_user_role INT;
BEGIN
    RAISE NOTICE 'Assigning default permissions for User=% to Role=%', p_user_id, p_role_id;

    -- 1️⃣ Ensure user exists in organization_users
    SELECT COUNT(*) INTO v_existing_organization_user
    FROM organization_users ou
    WHERE ou.user_id = p_user_id
      AND ou.organization_id = p_organization_id
      AND ou.is_deleted = FALSE;

    IF v_existing_organization_user = 0 THEN
        INSERT INTO organization_users (
            id, user_id, effective_start_date, created_on_utc,
            created_by, organization_id, is_deleted
        )
        VALUES (
            uuid_generate_v4(),
            p_user_id,
            NOW(),
            NOW(),
            COALESCE(p_created_by, p_user_id),
            p_organization_id,
            FALSE
        );
        RAISE NOTICE '✅ Added user to organization_users';
    END IF;

    -- 2️⃣ Ensure user has matching role in user_roles
    SELECT COUNT(*) INTO v_existing_user_role
    FROM user_roles ur
    WHERE ur.user_id = p_user_id
      AND ur.role_id = p_role_id
      AND ur.organization_id = p_organization_id
      AND ur.is_deleted = FALSE;

    IF v_existing_user_role = 0 THEN
        INSERT INTO user_roles (
            user_id, role_id, created_on_utc, created_by,
            is_deleted, start_date, organization_id
        )
        VALUES (
            p_user_id,
            p_role_id,
            NOW(),
            COALESCE(p_created_by, p_user_id),
            FALSE,
            NOW(),
            p_organization_id
        );
        RAISE NOTICE '✅ Added role assignment for user';
    END IF;

    -- 3️⃣ Assign permissions from role_permissions (NOT template mappings)
    INSERT INTO user_permissions (
        user_id,
        permission_id,
        organization_id,
        created_on_utc,
        created_by,
        is_deleted
    )
    SELECT
        p_user_id,
        rp.permission_id,
        p_organization_id,
        NOW(),
        COALESCE(p_created_by, p_user_id),
        FALSE
    FROM role_permissions rp
    WHERE rp.role_id = p_role_id
      AND NOT EXISTS (
          SELECT 1
          FROM user_permissions up
          WHERE up.user_id = p_user_id
            AND up.permission_id = rp.permission_id
            AND up.organization_id = p_organization_id
            AND up.is_deleted = FALSE
      );

    GET DIAGNOSTICS v_permission_count = ROW_COUNT;

    RAISE NOTICE '✅ Assigned % permissions to User=% for Role=%', 
        v_permission_count, p_user_id, p_role_id;

EXCEPTION
    WHEN OTHERS THEN
        RAISE WARNING '⚠️ Error assigning permissions for user %: %', p_user_id, SQLERRM;
END;
$function$

-- Function: upsert_role_permissions
CREATE OR REPLACE FUNCTION public.upsert_role_permissions(p_role_id integer, p_permission_ids uuid[], p_user_id uuid)
 RETURNS void
 LANGUAGE plpgsql
AS $function$
BEGIN
    -- 1️⃣ Reactivate existing soft-deleted permissions that are now in the list
    UPDATE public.role_permissions
    SET is_deleted = FALSE,
        deleted_on_utc = NULL,
        modified_on_utc = NOW(),
        modified_by = p_user_id
    WHERE role_id = p_role_id
      AND permission_id = ANY(p_permission_ids)
      AND is_deleted = TRUE;

    -- 2️⃣ Insert missing (new) permissions
    INSERT INTO public.role_permissions (
        role_id,
        permission_id,
        created_on_utc,
        created_by,
        is_deleted
    )
    SELECT
        p_role_id,
        pid,
        NOW(),
        p_user_id,
        FALSE
    FROM UNNEST(p_permission_ids) AS pid
    WHERE NOT EXISTS (
        SELECT 1
        FROM public.role_permissions rp
        WHERE rp.role_id = p_role_id
          AND rp.permission_id = pid
    );

    -- 3️⃣ Soft delete permissions not in the provided list
    UPDATE public.role_permissions
    SET is_deleted = TRUE,
        deleted_on_utc = NOW(),
        modified_on_utc = NOW(),
        modified_by = p_user_id
    WHERE role_id = p_role_id
      AND permission_id NOT IN (SELECT unnest(p_permission_ids))
      AND is_deleted = FALSE;
END;
$function$

-- Function: get_outstanding_invoices_by_customer_id
CREATE OR REPLACE FUNCTION public.get_outstanding_invoices_by_customer_id(p_company_id uuid, p_customer_id uuid)
 RETURNS TABLE(customer_name text, coa_name text, amount numeric, due_date date, aging_bucket text)
 LANGUAGE plpgsql
AS $function$
BEGIN
    RETURN QUERY
    SELECT        
        c.name::text AS customer_name,
        coa.name AS coa_name,
        je.amount,
        (th.transaction_date + INTERVAL '30 days')::date AS due_date,  
        CASE 
            WHEN (th.transaction_date + INTERVAL '30 days') <= CURRENT_DATE 
                THEN 'Current'
            WHEN (th.transaction_date + INTERVAL '30 days') BETWEEN CURRENT_DATE - INTERVAL '30 days' AND CURRENT_DATE 
                THEN '1-30 Days Past Due'
            WHEN (th.transaction_date + INTERVAL '60 days') BETWEEN CURRENT_DATE - INTERVAL '60 days' AND CURRENT_DATE - INTERVAL '31 days' 
                THEN '31-60 Days Past Due'
            ELSE 'Over 60 Days Past Due'
        END AS aging_bucket
    FROM 
        public.journal_entries je
    JOIN 
        public.transaction_headers th ON je.transaction_id = th.id
    JOIN 
        public.chart_of_accounts coa ON je.account_id = coa.id
    JOIN 
        public.customers c ON th.customer_id = c.id
    WHERE 
        coa.account_type_id = (SELECT id FROM public.account_types WHERE name = 'Accounts Receivable')
        AND je.is_deleted = false
        AND th.company_id = p_company_id
        AND th.customer_id = p_customer_id
        AND (th.transaction_date + INTERVAL '30 days') <= CURRENT_DATE
    ORDER BY 
       (th.transaction_date + INTERVAL '30 days')::date;
END;
$function$

-- Function: get_outstanding_invoices_by_customer
CREATE OR REPLACE FUNCTION public.get_outstanding_invoices_by_customer(p_company_id uuid, p_customer_id uuid, p_start_date date DEFAULT NULL::date, p_end_date date DEFAULT NULL::date)
 RETURNS TABLE(customer_name text, coa_name text, amount numeric, due_date date, aging_bucket text)
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_start_date date := COALESCE(p_start_date, CURRENT_DATE - INTERVAL '365 days');
    v_end_date   date := COALESCE(p_end_date, CURRENT_DATE);
BEGIN
    RETURN QUERY
    SELECT
        c.name::text AS customer_name,
        coa.name     AS coa_name,
        je.amount,
        (th.transaction_date + INTERVAL '30 days')::date AS due_date,

        /* Aging bucket calculation */
        CASE
            WHEN (th.transaction_date + INTERVAL '30 days') <= CURRENT_DATE
                THEN 'Current'
            WHEN (th.transaction_date + INTERVAL '30 days') BETWEEN CURRENT_DATE - INTERVAL '30 days' AND CURRENT_DATE
                THEN '1-30 Days Past Due'
            WHEN (th.transaction_date + INTERVAL '60 days') BETWEEN CURRENT_DATE - INTERVAL '60 days' AND CURRENT_DATE - INTERVAL '31 days'
                THEN '31-60 Days Past Due'
            ELSE 'Over 60 Days Past Due'
        END AS aging_bucket

    FROM public.journal_entries je
    JOIN public.transaction_headers th ON je.transaction_id = th.id
    JOIN public.chart_of_accounts coa ON je.account_id = coa.id
    JOIN public.customers c ON th.customer_id = c.id

    WHERE
        th.company_id = p_company_id
        AND th.customer_id = p_customer_id
        AND je.is_deleted = false
        AND coa.account_type_id = (
                SELECT id FROM public.account_types WHERE name = 'Accounts Receivable'
            )

        /* Overdue invoices only (due_date <= today) */
        AND (th.transaction_date + INTERVAL '30 days')::date <= CURRENT_DATE

        /* Date range filtering */
        AND th.transaction_date::date BETWEEN v_start_date AND v_end_date

    ORDER BY (th.transaction_date + INTERVAL '30 days')::date;
END;
$function$

-- Function: postgres_fdw_handler
CREATE OR REPLACE FUNCTION public.postgres_fdw_handler()
 RETURNS fdw_handler
 LANGUAGE c
 STRICT
AS '$libdir/postgres_fdw', $function$postgres_fdw_handler$function$

-- Function: postgres_fdw_validator
CREATE OR REPLACE FUNCTION public.postgres_fdw_validator(text[], oid)
 RETURNS void
 LANGUAGE c
 STRICT
AS '$libdir/postgres_fdw', $function$postgres_fdw_validator$function$

-- Function: postgres_fdw_disconnect
CREATE OR REPLACE FUNCTION public.postgres_fdw_disconnect(text)
 RETURNS boolean
 LANGUAGE c
 PARALLEL RESTRICTED STRICT
AS '$libdir/postgres_fdw', $function$postgres_fdw_disconnect$function$

-- Function: postgres_fdw_disconnect_all
CREATE OR REPLACE FUNCTION public.postgres_fdw_disconnect_all()
 RETURNS boolean
 LANGUAGE c
 PARALLEL RESTRICTED STRICT
AS '$libdir/postgres_fdw', $function$postgres_fdw_disconnect_all$function$

-- Function: postgres_fdw_get_connections
CREATE OR REPLACE FUNCTION public.postgres_fdw_get_connections(check_conn boolean DEFAULT false, OUT server_name text, OUT user_name text, OUT valid boolean, OUT used_in_xact boolean, OUT closed boolean, OUT remote_backend_pid integer)
 RETURNS SETOF record
 LANGUAGE c
 PARALLEL RESTRICTED STRICT
AS '$libdir/postgres_fdw', $function$postgres_fdw_get_connections_1_2$function$

-- Function: notify_user_permission_change
CREATE OR REPLACE FUNCTION public.notify_user_permission_change()
 RETURNS trigger
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_user_id uuid;
    v_org_id uuid;
    payload json;
BEGIN
    -- Handle DELETE separately (NEW is null)
    IF TG_OP = 'DELETE' THEN
        v_user_id := OLD.user_id;
        v_org_id  := OLD.organization_id;
    ELSE
        v_user_id := NEW.user_id;
        v_org_id  := NEW.organization_id;
    END IF;

    payload := json_build_object(
        'entity', 'user_permissions',
        'operation', TG_OP,
        'userId', v_user_id,
        'organizationId', v_org_id,
        'occurredAt', now()
    );

    PERFORM pg_notify('permission_user_changed', payload::text);

    RETURN NULL;
END;
$function$

-- Function: get_system_user_id
CREATE OR REPLACE FUNCTION public.get_system_user_id()
 RETURNS uuid
 LANGUAGE plpgsql
AS $function$
DECLARE
    v_user_id uuid;
BEGIN
    SELECT id
    INTO v_user_id
    FROM public.users
    WHERE first_name = 'System'
      AND is_deleted = false
    LIMIT 1;


    RETURN COALESCE(
        v_user_id,
        'dd4f94f2-0f79-4748-b94b-bf935e3944c7'::uuid
    );
END;
$function$

-- Function: upsert_user_roles
CREATE OR REPLACE FUNCTION public.upsert_user_roles(p_user_id uuid, p_role_ids integer[], p_organization_id uuid, p_created_by uuid)
 RETURNS void
 LANGUAGE plpgsql
AS $function$
BEGIN
    INSERT INTO public.user_roles
    (
        user_id,
        role_id,
        organization_id,
        created_on_utc,
        created_by,
        is_deleted,
        start_date,
        end_date
     )
    SELECT
        p_user_id,
        role_id,
        p_organization_id,
        NOW(),
        p_created_by,
        false,
        NOW(),
        NOW() + INTERVAL '1 year'
    FROM UNNEST(p_role_ids) AS role_id
    ON CONFLICT (user_id, role_id, organization_id)
    DO UPDATE
    SET
        is_deleted = false,
        start_date = NOW(),
        end_date = NOW() + INTERVAL '1 year',
        modified_on_utc = NOW(),
        modified_by = p_created_by;
END;
$function$

-- Function: upsert_user_permissions_from_user_roles
CREATE OR REPLACE FUNCTION public.upsert_user_permissions_from_user_roles(p_user_id uuid, p_organization_id uuid, p_role_ids integer[], p_created_by uuid)
 RETURNS void
 LANGUAGE plpgsql
AS $function$
BEGIN
    /*
     * STEP 1: Insert or revive permissions coming from roles
     */
    INSERT INTO public.user_permissions (
        user_id,
        organization_id,
        permission_id,
        created_on_utc,
        created_by,
        is_deleted,
        is_explicit
    )
    SELECT DISTINCT
        p_user_id,
        p_organization_id,
        rp.permission_id,
        now(),
        p_created_by,
        false,
        false            -- role-derived
    FROM public.role_permissions rp
    WHERE rp.role_id = ANY (p_role_ids)
      AND rp.is_deleted = false

    ON CONFLICT (user_id, organization_id, permission_id)
    DO UPDATE
    SET
        is_deleted = false,
        deleted_on_utc = NULL,
        modified_on_utc = now(),
        modified_by = p_created_by,
        is_explicit = false;

    /*
     * STEP 2: Soft-delete role-derived permissions
     *         that are no longer present in current roles
     */
    UPDATE public.user_permissions up
    SET
        is_deleted = true,
        deleted_on_utc = now(),
        modified_on_utc = now(),
        modified_by = p_created_by
    WHERE up.user_id = p_user_id
      AND up.organization_id = p_organization_id
      AND up.is_explicit = false
      AND up.is_deleted = false
      AND up.permission_id NOT IN (
          SELECT DISTINCT rp.permission_id
          FROM public.role_permissions rp
          WHERE rp.role_id = ANY (p_role_ids)
            AND rp.is_deleted = false
      );
END;
$function$

-- Function: sync_user_permissions_from_roles
CREATE OR REPLACE FUNCTION public.sync_user_permissions_from_roles(p_user_id uuid DEFAULT NULL::uuid, p_organization_id uuid DEFAULT NULL::uuid, p_triggered_by text DEFAULT 'manual'::text, p_notes text DEFAULT NULL::text)
 RETURNS uuid
 LANGUAGE plpgsql
AS $function$
DECLARE
    -- Sync run tracking
    v_sync_run_id uuid := gen_random_uuid();

    -- Loop variables
    v_user_id uuid;
    v_org_id uuid;
    v_role_id int;
    v_permission_id uuid;

    -- For UPSERT result
    v_user_permission_id int;
BEGIN
    /*
    ============================================================
    START SYNC RUN
    ============================================================
    */
    INSERT INTO public.user_permission_sync_runs (
        id,
        started_on_utc,
        triggered_by,
        notes
    )
    VALUES (
        v_sync_run_id,
        NOW(),
        p_triggered_by,
        p_notes
    );

    /*
    ============================================================
    MAIN SYNC LOOP
    - Filtered by optional user / organization
    ============================================================
    */
    FOR v_user_id, v_org_id IN
        SELECT DISTINCT
            ur.user_id,
            ur.organization_id
        FROM public.user_roles ur
        WHERE ur.is_deleted = false
          AND (p_user_id IS NULL OR ur.user_id = p_user_id)
          AND (p_organization_id IS NULL OR ur.organization_id = p_organization_id)
    LOOP

        /*
        --------------------------------------------------------
        LOOP ROLES FOR USER + ORGANIZATION
        --------------------------------------------------------
        */
        FOR v_role_id IN
            SELECT ur.role_id
            FROM public.user_roles ur
            WHERE ur.user_id = v_user_id
              AND ur.organization_id = v_org_id
              AND ur.is_deleted = false
        LOOP

            /*
            ----------------------------------------------------
            LOOP PERMISSIONS FOR ROLE
            ----------------------------------------------------
            */
            FOR v_permission_id IN
                SELECT rp.permission_id
                FROM public.role_permissions rp
                WHERE rp.role_id = v_role_id
                  AND rp.is_deleted = false
            LOOP

                /*
                ------------------------------------------------
                UPSERT USER PERMISSION (SAFE)
                ------------------------------------------------
                */
                INSERT INTO public.user_permissions (
                    user_id,
                    permission_id,
                    organization_id,
                    created_on_utc,
                    created_by,
                    is_deleted,
                    modified_on_utc,
                    modified_by,
                    deleted_on_utc
                )
                VALUES (
                    v_user_id,
                    v_permission_id,
                    v_org_id,
                    NOW(),
                    v_user_id,
                    false,
                    NULL,
                    NULL,
                    NULL
                )
                ON CONFLICT (user_id, organization_id, permission_id)
                DO UPDATE
                SET
                    is_deleted = false,
                    deleted_on_utc = NULL,
                    modified_on_utc = NOW(),
                    modified_by = v_user_id
                WHERE public.user_permissions.is_deleted = true
                RETURNING id
                INTO v_user_permission_id;

                /*
                ------------------------------------------------
                BACKUP / DELTA SNAPSHOT
                - Only when INSERT or REVIVE happened
                ------------------------------------------------
                */
                IF FOUND THEN
                    INSERT INTO public.user_permission_sync_deltas (
                        id,
                        sync_run_id,
                        user_permission_id,
                        user_id,
                        organization_id,
                        permission_id,
                        action,
                        created_on_utc
                    )
                    VALUES (
                        gen_random_uuid(),
                        v_sync_run_id,
                        v_user_permission_id,
                        v_user_id,
                        v_org_id,
                        v_permission_id,
                        'UPSERT',
                        NOW()
                    );
                END IF;

            END LOOP; -- permissions
        END LOOP; -- roles
    END LOOP; -- users + organizations

    /*
    ============================================================
    COMPLETE SYNC RUN
    ============================================================
    */
    UPDATE public.user_permission_sync_runs
    SET completed_on_utc = NOW()
    WHERE id = v_sync_run_id;

    RETURN v_sync_run_id;
END;
$function$

-- Procedure: assign_default_users_to_organization
CREATE OR REPLACE PROCEDURE public.assign_default_users_to_organization(IN p_organization_id uuid, IN p_permission_ids uuid[], IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
  loop_user_id UUID;
BEGIN
    -- Insert default users into organization_users (only if they don't exist)
    INSERT INTO public.organization_users (
        id,
        user_id,
        effective_start_date,
        effective_end_date,
        created_on_utc,
        created_by,
        organization_id
    )
    SELECT
        gen_random_uuid(),
        d.user_id,
        NOW(),
        DATE '9999-12-31',
        NOW(),
        p_created_by,
        p_organization_id
    FROM
        public.default_organization_users d
    WHERE NOT EXISTS (
        SELECT 1
        FROM public.organization_users ou
        WHERE ou.user_id = d.user_id
          AND ou.organization_id = p_organization_id
    );

    RAISE NOTICE 'Added % default users to organization %',
        (SELECT COUNT(*) FROM public.default_organization_users), p_organization_id;

    -- Assign permissions for these users by calling insert_user_permission
    FOR loop_user_id IN (SELECT d.user_id
        FROM public.default_organization_users d)
    LOOP
        CALL public.insert_user_permission(
            loop_user_id,
            p_organization_id,
            p_permission_ids,
            p_created_by
        );
    END LOOP;
    RAISE NOTICE 'Attempted to assign permission % to default users in organization %',
        p_permission_ids,
        p_organization_id;
END;
$procedure$

-- Procedure: hard_delete_organization
CREATE OR REPLACE PROCEDURE public.hard_delete_organization(IN p_organization_id uuid)
 LANGUAGE plpgsql
AS $procedure$
BEGIN
    -- Delete from user_permissions (cascading through organization and users)
    DELETE FROM user_permissions
    WHERE organization_id = p_organization_id;

    -- Delete from organization_users (cascading through organization)
    DELETE FROM organization_users
    WHERE organization_id = p_organization_id;

    -- Delete from company_finance_year (cascading through companies)
    DELETE FROM company_finance_year
    WHERE company_id IN (
        SELECT id FROM companies WHERE organization_id = p_organization_id
    );

    -- Delete from company_users (cascading through companies)
    DELETE FROM company_users
    WHERE company_id IN (
        SELECT id FROM companies WHERE organization_id = p_organization_id
    );

    -- Delete from company_contacts (cascading through companies)
    DELETE FROM company_contacts
    WHERE company_id IN (
        SELECT id FROM companies WHERE organization_id = p_organization_id
    );

    -- Delete from contacts (cascading through companies)
    DELETE FROM contacts
    WHERE id IN (
        SELECT contact_id FROM company_contacts
        WHERE company_id IN (
            SELECT id FROM companies WHERE organization_id = p_organization_id
        )
    );

	--delete from company_preference
	DELETE FROM public.company_preferences
	WHERE company_id in (SELECT id from public.companies where organization_id = p_organization_id);

    -- Delete from companies (cascading through organization)
    DELETE FROM companies
    WHERE organization_id = p_organization_id;

	DELETE FROM organization_accounts
    WHERE organization_id = p_organization_id;

    -- Delete from chart_of_accounts (cascading through organization)
    DELETE FROM chart_of_accounts
    WHERE organization_id = p_organization_id;

    -- Finally, delete the organization itself
    DELETE FROM organizations
    WHERE id = p_organization_id;

    -- Optional: Log the deletion action
    RAISE NOTICE 'Organization with ID % and all related data have been hard deleted.', 
        p_organization_id;

END;
$procedure$

-- Procedure: initilize_organization
-- SOURCE
CREATE OR REPLACE PROCEDURE public.initilize_organization(IN p_id uuid, IN p_name text, IN p_company_guids text, IN p_company_names text, IN p_user_id uuid, IN p_user_first_name text, IN p_user_last_name text, IN p_phone_number character varying, IN p_email character varying, IN p_gstin text, IN p_description text, IN p_tag_line text, IN p_short_name text, IN p_pan text, IN p_tan text, IN p_address_line1 text, IN p_address_line2 text, IN p_country_id uuid, IN p_state_id uuid, IN p_city_name text, IN p_zip_code text, IN p_created_by uuid, IN p_default_company_id uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_city_id uuid;
    v_address_id uuid;     -- Generate a unique address ID
    v_user_id uuid;        -- Generate a unique user ID
    v_permission_ids uuid[]; 
    v_company_names text[];  -- Array to hold parsed company names
    v_company_guids uuid[];  -- Array to hold parsed company GUIDs
    v_company_name text;     -- Variable for iterating through company names
    v_company_guid uuid;     -- Variable for iterating through company GUIDs
	v_user_company_id uuid;

    -- Constants for default organization and company IDs
    DEFAULT_ORGANIZATION_ID CONSTANT uuid := '68929d37-b647-4d7b-8c91-7dfe2396c93b'; 
    --DEFAULT_COMPANY_ID CONSTANT uuid := '048000ba-e62c-474b-b5eb-fe629a4dc863';
    ADMIN_PERMISSION CONSTANT text := 'Dhanman.Admin';
BEGIN
	

	 -- Parse company names and GUIDs into arrays
    v_company_names := string_to_array(p_company_names, ',');
    v_company_guids := string_to_array(p_company_guids, ',');

    -- Get city_id
    v_city_id := get_city_id(p_city_name, p_zip_code, p_state_id, p_created_by);
    
    -- Get address_id
    v_address_id := get_address_id(p_country_id, p_state_id , v_city_id , p_address_line1, p_zip_code, p_created_by, p_address_line2);

	 v_user_company_id := v_company_guids[1]; -- Pick the first company ID
   
    -- Create and get user_id
    v_user_id := create_user(p_user_id, v_user_company_id, p_email, p_phone_number, p_user_first_name, p_user_last_name, v_address_id,  p_created_by);
    RAISE NOTICE 'Generated User ID: %',v_user_company_id;

    -- Print the generated address_id and fetched state_id and country_id
    RAISE NOTICE 'Generated address_id: %, City ID: %, Country ID: %, User ID: %', v_address_id, v_city_id, p_country_id, v_user_id;
    
	-- Check if organization exists by any unique identifier
   IF NOT EXISTS (SELECT 1 FROM organizations WHERE id = p_id) THEN
    -- Only create organization if no matching record exists
      CALL public.create_organization(
        p_id,
        p_name,
        p_description,
        p_phone_number,
        p_email,
        p_address_line1,
        p_gstin,
        p_tag_line,
        v_city_id,
        p_short_name,
        p_pan,
        p_tan,
        p_created_by
      );
    
        RAISE NOTICE 'Organization ID % successfully inserted.', p_id;
   ELSE
        RAISE NOTICE 'Organization with ID % already exists. Skipping organization creation.', p_id;
   END IF;

    -- Insert into organization_users table to link the generated user to the organization
    CALL public.insert_organization_user(v_user_id, p_created_by, p_id);   

    -- Fetch the permission_id for 'Dhanman.Admin'
  	SELECT array_agg(id) INTO v_permission_ids
	FROM permissions
	WHERE name = ADMIN_PERMISSION;

    CALL public.insert_user_permission(
        v_user_id ,
        p_id ,
        v_permission_ids,
        p_created_by
    );

    -- Assign all default users and default permissions as admin
    CALL public.assign_default_users_to_organization(p_id, v_permission_ids, p_created_by);

    -- Iterate through the company names and GUIDs
    FOR i IN 1..array_length(v_company_names, 1) LOOP
        v_company_name := v_company_names[i];
        v_company_guid := v_company_guids[i];
        
        -- Call initialize_company for each company
        CALL public.initialize_company(
            v_company_guid, 
            p_id,  
            v_company_name, 
            p_description, 
            p_gstin, 
            p_pan, 
            p_tan, 
            'INR', 
            p_short_name, 
            p_tag_line, 
            p_name, 
            p_phone_number, 
            p_email, 
            p_created_by, 
            v_user_id,
			p_default_company_id
        );
        
        RAISE NOTICE 'Company % initialized with GUID %.', v_company_name, v_company_guid;
    END LOOP;

    -- Call initialize_org_coa to copy chart_of_accounts from the old organization to the new organization
    CALL public.initialize_org_coa(
        DEFAULT_ORGANIZATION_ID, -- Old organization ID
        p_id,       -- New organization ID
        p_company_guids, -- New Company Id
        p_created_by
    ); 

    -- Print a confirmation after the chart_of_accounts is copied
    RAISE NOTICE 'Chart of accounts successfully copied from organization % to %.', DEFAULT_ORGANIZATION_ID, p_id;

END;
$procedure$


-- TARGET
CREATE OR REPLACE PROCEDURE public.initilize_organization(IN p_id uuid, IN p_name text, IN p_company_guids text, IN p_company_names text, IN p_user_id uuid, IN p_user_first_name text, IN p_user_last_name text, IN p_phone_number character varying, IN p_email character varying, IN p_gstin text, IN p_description text, IN p_tag_line text, IN p_short_name text, IN p_pan text, IN p_tan text, IN p_address_line1 text, IN p_address_line2 text, IN p_country_id uuid, IN p_state_id uuid, IN p_city_name text, IN p_zip_code text, IN p_created_by uuid, IN p_default_company_id uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_city_id uuid;
    v_address_id uuid;     -- Generate a unique address ID
    v_user_id uuid;        -- Generate a unique user ID
    v_permission_id uuid; 
    v_company_names text[];  -- Array to hold parsed company names
    v_company_guids uuid[];  -- Array to hold parsed company GUIDs
    v_company_name text;     -- Variable for iterating through company names
    v_company_guid uuid;     -- Variable for iterating through company GUIDs
	v_user_company_id uuid;

    -- Constants for default organization and company IDs
    DEFAULT_ORGANIZATION_ID CONSTANT uuid := '68929d37-b647-4d7b-8c91-7dfe2396c93b'; 
    --DEFAULT_COMPANY_ID CONSTANT uuid := '048000ba-e62c-474b-b5eb-fe629a4dc863';
    ADMIN_PERMISSION CONSTANT text := 'Dhanman.Admin';
BEGIN
	

	 -- Parse company names and GUIDs into arrays
    v_company_names := string_to_array(p_company_names, ',');
    v_company_guids := string_to_array(p_company_guids, ',');

    -- Get city_id
    v_city_id := get_city_id(p_city_name, p_zip_code, p_state_id, p_created_by);
    
    -- Get address_id
    v_address_id := get_address_id(p_country_id, p_state_id , v_city_id , p_address_line1, p_zip_code, p_created_by, p_address_line2);

	 v_user_company_id := v_company_guids[1]; -- Pick the first company ID
   
    -- Create and get user_id
    v_user_id := create_user(p_user_id, v_user_company_id, p_email, p_phone_number, p_user_first_name, p_user_last_name, v_address_id,  p_created_by);
    RAISE NOTICE 'Generated User ID: %',v_user_company_id;

    -- Print the generated address_id and fetched state_id and country_id
    RAISE NOTICE 'Generated address_id: %, City ID: %, Country ID: %, User ID: %', v_address_id, v_city_id, p_country_id, v_user_id;
    
	-- Check if organization exists by any unique identifier
   IF NOT EXISTS (SELECT 1 FROM organizations WHERE id = p_id) THEN
    -- Only create organization if no matching record exists
      CALL public.create_organization(
        p_id,
        p_name,
        p_description,
        p_phone_number,
        p_email,
        p_address_line1,
        p_gstin,
        p_tag_line,
        v_city_id,
        p_short_name,
        p_pan,
        p_tan,
        p_created_by
      );
    
        RAISE NOTICE 'Organization ID % successfully inserted.', p_id;
   ELSE
        RAISE NOTICE 'Organization with ID % already exists. Skipping organization creation.', p_id;
   END IF;

    -- Insert into organization_users table to link the generated user to the organization
    CALL public.insert_organization_user(v_user_id, p_created_by, p_id);   

    -- Fetch the permission_id for 'Dhanman.Admin'
    SELECT id INTO v_permission_id
    FROM permissions
    WHERE name = ADMIN_PERMISSION;

    CALL public.insert_user_permission(
        v_user_id ,
        p_id ,
        v_permission_id,
        p_created_by
    );

    -- Assign all default users and default permissions as admin
    CALL public.assign_default_users_to_organization(p_id, v_permission_id, p_created_by);

    -- Iterate through the company names and GUIDs
    FOR i IN 1..array_length(v_company_names, 1) LOOP
        v_company_name := v_company_names[i];
        v_company_guid := v_company_guids[i];
        
        -- Call initialize_company for each company
        CALL public.initialize_company(
            v_company_guid, 
            p_id,  
            v_company_name, 
            p_description, 
            p_gstin, 
            p_pan, 
            p_tan, 
            'INR', 
            p_short_name, 
            p_tag_line, 
            p_name, 
            p_phone_number, 
            p_email, 
            p_created_by, 
            v_user_id,
			p_default_company_id
        );
        
        RAISE NOTICE 'Company % initialized with GUID %.', v_company_name, v_company_guid;
    END LOOP;

    -- Call initialize_org_coa to copy chart_of_accounts from the old organization to the new organization
    CALL public.initialize_org_coa(
        DEFAULT_ORGANIZATION_ID, -- Old organization ID
        p_id,       -- New organization ID
        p_company_guids, -- New Company Id
        p_created_by
    ); 

    -- Print a confirmation after the chart_of_accounts is copied
    RAISE NOTICE 'Chart of accounts successfully copied from organization % to %.', DEFAULT_ORGANIZATION_ID, p_id;

END;
$procedure$

-- Procedure: insert_company_user
CREATE OR REPLACE PROCEDURE public.insert_company_user(IN p_user_id uuid, IN p_created_by uuid, IN p_company_id uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_existing_id uuid;
    v_is_deleted boolean;
BEGIN
    -- Check if user-company relationship exists (including soft-deleted)
    SELECT id, is_deleted
    INTO v_existing_id, v_is_deleted
    FROM public.company_users
    WHERE user_id = p_user_id
      AND company_id = p_company_id
    LIMIT 1;

    -- If exists and active (not deleted), do nothing
    IF FOUND AND v_is_deleted = false THEN
        RAISE NOTICE 'User % already exists in company % (active), skipping insert.', p_user_id, p_company_id;

    -- If exists but soft-deleted, reactivate the record
    ELSIF FOUND AND v_is_deleted = true THEN
        UPDATE public.company_users
        SET is_deleted = false,
            modified_on_utc = NOW(),
            modified_by = p_created_by,
            deleted_on_utc = NULL
        WHERE id = v_existing_id;

        RAISE NOTICE 'User % re-activated in company % (id=%)', p_user_id, p_company_id, v_existing_id;

    -- If no record found, insert new
    ELSE
        INSERT INTO public.company_users (
            id,
            user_id,
            company_id,
            effective_start_date,
            effective_end_date,
            created_on_utc,
            created_by,
            is_deleted
        ) VALUES (
            gen_random_uuid(),
            p_user_id,
            p_company_id,
            NOW(),
            DATE '9999-12-31',
            NOW(),
            p_created_by,
            false
        );

        RAISE NOTICE 'Company-user relationship created for user % in company %', p_user_id, p_company_id;
    END IF;
END;
$procedure$

-- Procedure: insert_into_manual_journal
-- SOURCE
CREATE OR REPLACE PROCEDURE public.insert_into_manual_journal(IN p_company_id uuid, IN p_journal_header_id uuid, IN p_date date, IN p_amount numeric, IN p_note text, IN p_description text, IN p_is_debit boolean, IN p_account_id uuid, IN p_created_by uuid, IN p_journal_details_data jsonb, IN p_transaction_header_data jsonb, IN journal_entries_data jsonb)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_voucher_number character varying;
    v_voucher_detail JSONB;
    v_transaction_record JSONB;
    v_transaction_result RECORD;
    v_transactions_data JSONB;
BEGIN
    v_voucher_number := get_new_voucher_number(p_company_id, p_date);
    RAISE NOTICE 'new v_voucher_number: %', v_voucher_number;

    -- Insert into journal_voucher_headers
    INSERT INTO public.journal_voucher_headers(
        id,
        company_id,
        date,
        amount,
        note,
        is_debit,
        account_id,
        voucher_number,
        created_by,
        created_on_utc,
        is_deleted
    )
    VALUES (
        p_journal_header_id,
        p_company_id,
        p_date,
        p_amount,
        p_note,
        p_is_debit,
        p_account_id,
        v_voucher_number,
        p_created_by,
        CURRENT_TIMESTAMP,
        FALSE
    );

    RAISE NOTICE 'Inserted into journal_voucher_headers: %', p_journal_header_id;

    -- Insert into journal_voucher_details
    FOR v_voucher_detail IN SELECT * FROM jsonb_array_elements(p_journal_details_data)
    LOOP
        INSERT INTO public.journal_voucher_details(
            id,
            journal_header_id,
            credit_account_id,
            debit_account_id,
            amount,
            tds_tcs,
            narration,
            created_by,
            created_on_utc,
            is_deleted
        )
        VALUES (
            (v_voucher_detail->>'detail_id')::UUID,
            p_journal_header_id,
            (v_voucher_detail->>'credit_account_id')::UUID,
            (v_voucher_detail->>'debit_account_id')::UUID,
            (v_voucher_detail->>'amount')::NUMERIC,
            v_voucher_detail->>'tds_tcs',
            v_voucher_detail->>'narration',
            p_created_by,
            CURRENT_TIMESTAMP,
            FALSE
        );
        RAISE NOTICE 'Inserted into journal_voucher_details';
    END LOOP;

    -- Prepare single transaction record matching insert_multiple_transactions_and_journal_entries input
    v_transaction_record := jsonb_build_object(
        'company_id', p_transaction_header_data->>'company_id',
        'customer_id', p_transaction_header_data->>'customer_id',
        'vendor_id', p_transaction_header_data->>'vendor_id',
        'employee_id', p_transaction_header_data->>'employee_id',
        'transaction_date', p_transaction_header_data->>'transaction_date',
        'transaction_source_type', p_transaction_header_data->>'transaction_source_type',
        'status_id', p_transaction_header_data->>'status_id',
        'document_id', p_transaction_header_data->>'document_id',
        'document_number', v_voucher_number,
        'description', p_transaction_header_data->>'description',
        'user_id', p_created_by,
        'journal_entries', journal_entries_data
    );

    v_transactions_data := jsonb_build_array(v_transaction_record);

    -- Call the batch function to insert into transaction_headers and journal_entries (and narration)
    FOR v_transaction_result IN
        SELECT * FROM public.insert_multiple_transactions_and_journal_entries(v_transactions_data)
    LOOP
        RAISE NOTICE 'Inserted transaction_id: %, document_id: %',
            v_transaction_result.transaction_id, v_transaction_result.document_id;
        -- You can use v_transaction_result.transaction_id if you need to reference it for other inserts
    END LOOP;

EXCEPTION
    WHEN OTHERS THEN
        RAISE EXCEPTION 'Error occurred: %', SQLERRM;
END;
$procedure$


-- TARGET
CREATE OR REPLACE PROCEDURE public.insert_into_manual_journal(IN p_company_id uuid, IN p_journal_header_id uuid, IN p_date date, IN p_amount numeric, IN p_note text, IN p_description text, IN p_is_debit boolean, IN p_account_id uuid, IN p_created_by uuid, IN p_journal_details_data jsonb, IN p_transaction_header_data jsonb, IN journal_entries_data jsonb)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
	v_voucher_number character varying;
    v_voucher_detail JSONB;
 	v_transaction_id BIGINT;
    v_journal_entry JSONB;
BEGIN
     v_voucher_number := get_new_voucher_number(p_company_id,p_date);
     RAISE NOTICE 'new v_voucher_number: %', v_voucher_number;

    -- Insert into journal_voucher_headers
    INSERT INTO public.journal_voucher_headers(
        id,
		company_id,
        date,
        amount,
        note,
		is_debit,
		account_id,
		voucher_number,
        created_by,
        created_on_utc,
        is_deleted
    )
    VALUES (
        p_journal_header_id,
		p_company_id,
        p_date,
        p_amount,
        p_note,
		p_is_debit,
		p_account_id,
		v_voucher_number,
        p_created_by,
        CURRENT_TIMESTAMP,
        FALSE
    ); 

    RAISE NOTICE 'Inserted into journal_voucher_headers: %', p_journal_header_id;

    -- Loop through each journal entry and insert into journal_voucher_details
    FOR v_voucher_detail IN SELECT * FROM jsonb_array_elements(p_journal_details_data)
    LOOP
        INSERT INTO public.journal_voucher_details(
            id,        
            journal_header_id,
            credit_account_id,
            debit_account_id,
            amount,
            tds_tcs,
            narration,
            created_by,
            created_on_utc,
            is_deleted
        )
        VALUES (
            (v_voucher_detail->>'detail_id')::UUID,
            p_journal_header_id,
            (v_voucher_detail->>'credit_account_id')::UUID,
            (v_voucher_detail->>'debit_account_id')::UUID, 
            (v_voucher_detail->>'amount')::NUMERIC,
            v_voucher_detail->>'tds_tcs',
            v_voucher_detail->>'narration',
            p_created_by,
            CURRENT_TIMESTAMP,
            FALSE
        ); 
        RAISE NOTICE 'Inserted into journal_voucher_details';
    END LOOP;

	INSERT INTO public.transaction_headers (
            company_id,
            customer_id,
            vendor_id,
            employee_id,
            transaction_date,
            transaction_source_type,
            status_id,
            document_id,
            document_number,
            description,
            created_by,
            created_on_utc
    )
	VALUES(
        (p_transaction_header_data->>'company_id')::UUID,
        NULLIF((p_transaction_header_data->>'customer_id')::UUID, '00000000-0000-0000-0000-000000000000'),
        NULLIF((p_transaction_header_data->>'vendor_id')::UUID, '00000000-0000-0000-0000-000000000000'),
        NULLIF((p_transaction_header_data->>'employee_id')::UUID, '00000000-0000-0000-0000-000000000000'),
        (p_transaction_header_data->>'transaction_date')::DATE,
        (p_transaction_header_data->>'transaction_source_type')::INT,
        (p_transaction_header_data->>'status_id')::INT,
		(p_transaction_header_data->>'document_id')::UUID,
        v_voucher_number,
		(p_transaction_header_data->>'description')::TEXT,
        p_created_by,
        CURRENT_TIMESTAMP
    )
    RETURNING id INTO v_transaction_id;
    
	-- Loop through each journal entry and insert
    FOR v_journal_entry IN SELECT * FROM jsonb_array_elements(journal_entries_data)
    LOOP
		RAISE NOTICE 'transaction_date: %', (v_journal_entry->>'transaction_date')::DATE;
         INSERT INTO public.journal_entries (
            transaction_id,
            account_id,
            transaction_date,
            amount,
            entry_type,
            description_template_id,
            dynamic_data,
            entry_source_id
        )
        VALUES (
            v_transaction_id,
            (v_journal_entry->>'account_id')::uuid,
            (v_journal_entry->>'transaction_date')::date,
            (v_journal_entry->>'amount')::decimal,
            (v_journal_entry->>'entry_type')::char,
            (v_journal_entry->>'description_template_id')::int,
            (v_journal_entry->>'dynamic_data')::jsonb,
            (v_journal_entry->>'entry_source_id')::int
        );
    END LOOP;

END;
$procedure$

-- Procedure: insert_organization_user
-- SOURCE
CREATE OR REPLACE PROCEDURE public.insert_organization_user(IN p_user_id uuid, IN p_created_by uuid, IN p_organization_id uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_existing_id uuid;
    v_is_deleted boolean;
BEGIN
    -- Check if user-organization relationship exists (including soft-deleted)
    SELECT id, is_deleted
    INTO v_existing_id, v_is_deleted
    FROM public.organization_users
    WHERE user_id = p_user_id
      AND organization_id = p_organization_id
    LIMIT 1;

 -- If exists and active (not deleted), do nothing
 -- If exists and active (not deleted), do nothing
 -- If exists and active (not deleted), do nothing
 -- If exists and active (not deleted), do nothing
    -- If exists and active (not deleted), do nothing
    IF FOUND AND v_is_deleted = false THEN
        RAISE NOTICE 'User % already exists in organization % (active), skipping insert.', p_user_id, p_organization_id;

    -- If exists but soft-deleted, reactivate the record
    ELSIF FOUND AND v_is_deleted = true THEN
        UPDATE public.organization_users
        SET is_deleted = false,
            modified_on_utc = NOW(),
            modified_by = p_created_by,
            deleted_on_utc = NULL
        WHERE id = v_existing_id;

        RAISE NOTICE 'User % re-activated in organization % (id=%)', p_user_id, p_organization_id, v_existing_id;

    -- If no record found, insert new
    ELSE
        INSERT INTO public.organization_users(
            id,
            user_id,
            organization_id,
            effective_start_date,
            effective_end_date,
            created_on_utc,
            created_by,
            is_deleted
        )
        VALUES (
            gen_random_uuid(),
            p_user_id,
            p_organization_id,
            NOW(),
            DATE '9999-12-31',
            NOW(),
            p_created_by,
            false
        );

        RAISE NOTICE 'Organization-user relationship created for user % in organization %', p_user_id, p_organization_id;
    END IF;
END;
$procedure$


-- TARGET
CREATE OR REPLACE PROCEDURE public.insert_organization_user(IN p_user_id uuid, IN p_created_by uuid, IN p_organization_id uuid)
 LANGUAGE plpgsql
AS $procedure$
BEGIN
    -- Check if this user-organization relationship already exists
    IF NOT EXISTS (
        SELECT 1 
        FROM public.organization_users 
        WHERE user_id = p_user_id 
          AND organization_id = p_organization_id
    ) THEN
        -- Only insert if the relationship doesn't exist
        INSERT INTO public.organization_users (
            id,
            user_id,
            effective_start_date,
            effective_end_date,
            created_on_utc,
            created_by,
            organization_id
        ) VALUES (
            gen_random_uuid(),       
            p_user_id,             
            NOW(),                  
            DATE '9999-12-31',    
            NOW(),                 
            p_created_by,         
            p_organization_id     
        );
        
        RAISE NOTICE 'Organization-user relationship created for user % in organization %', p_user_id, p_organization_id;
    ELSE
        RAISE NOTICE 'User % already exists in organization %. Skipping insertion.', p_user_id, p_organization_id;
    END IF;
END;
$procedure$

-- Procedure: insert_user_role
CREATE OR REPLACE PROCEDURE public.insert_user_role(IN p_user_id uuid, IN p_role_id integer, IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_existing_id INT;
    v_is_deleted BOOLEAN;
BEGIN
    -- Look for existing role assignment for user
    SELECT id, is_deleted
    INTO v_existing_id, v_is_deleted
    FROM public.user_roles
    WHERE user_id = p_user_id
      AND role_id = p_role_id
    LIMIT 1;

    -- Case 1: Record exists and active -> do nothing
    IF FOUND AND v_is_deleted = false THEN
        RAISE NOTICE 'Role % already active for user %, skipping insert', p_role_id, p_user_id;

    -- Case 2: Record exists but soft-deleted -> reactivate
    ELSIF FOUND AND v_is_deleted = true THEN
        UPDATE public.user_roles
        SET is_deleted = false,
            modified_on_utc = NOW(),
            modified_by = p_created_by,
            deleted_on_utc = NULL
        WHERE id = v_existing_id;

        RAISE NOTICE 'Role % re-activated for user % (id=%)', p_role_id, p_user_id, v_existing_id;

    -- Case 3: No record - insert new
    ELSE
        INSERT INTO public.user_roles (
            user_id,
            role_id,
            created_on_utc,
            created_by,
            is_deleted,
            start_date,
            end_date
        )
        VALUES (
            p_user_id,
            p_role_id,
            NOW(),
            p_created_by,
            false,
            NOW(),                              -- Fixed start_date as now()
            '9999-12-31 00:00:00'::timestamp   -- Fixed end_date as default far future
        );

        RAISE NOTICE 'Role % assigned to user % (new)', p_role_id, p_user_id;
    END IF;
END;
$procedure$

-- Procedure: insert_user_roles
CREATE OR REPLACE PROCEDURE public.insert_user_roles(IN p_user_id uuid, IN p_role_ids integer[], IN p_organization_id uuid, IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_role_id integer;
    v_existing_id INT;
    v_is_deleted BOOLEAN;
BEGIN
    FOREACH v_role_id IN ARRAY p_role_ids
    LOOP
        -- Find matching user-role-org record
        SELECT id, is_deleted
        INTO v_existing_id, v_is_deleted
        FROM public.user_roles
        WHERE user_id = p_user_id
          AND role_id = v_role_id
          AND organization_id = p_organization_id
        LIMIT 1;

        -- If active record exists -> do nothing
        IF FOUND AND v_is_deleted = false THEN
            RAISE NOTICE 'Role % already active for user % in organization %, skipping insert', v_role_id, p_user_id, p_organization_id;

        -- If found and soft-deleted -> reactivate
        ELSIF FOUND AND v_is_deleted = true THEN
            UPDATE public.user_roles
            SET is_deleted = false,
                modified_on_utc = NOW(),
                modified_by = p_created_by,
                deleted_on_utc = NULL
            WHERE id = v_existing_id;
            RAISE NOTICE 'Role % re-activated for user % in organization % (id=%)', v_role_id, p_user_id, p_organization_id, v_existing_id;

        -- No record exists, insert new
        ELSE
            INSERT INTO public.user_roles (
                user_id,
                role_id,
                organization_id,
                created_on_utc,
                created_by,
                is_deleted,
                start_date,
                end_date
            )
            VALUES (
                p_user_id,
                v_role_id,
                p_organization_id,
                NOW(),
                p_created_by,
                false,
                NOW(),
                '9999-12-31 00:00:00'::timestamp
            );
            RAISE NOTICE 'Role % assigned to user % in organization % (new)', v_role_id, p_user_id, p_organization_id;
        END IF;
    END LOOP;
END;
$procedure$

-- Procedure: migrate_opening_balances_for_organization
CREATE OR REPLACE PROCEDURE public.migrate_opening_balances_for_organization(IN p_organization_id uuid, IN p_finyear_id integer, IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_status_id integer := 1;
    v_transaction_source_type_id integer := 18; -- as per your instruction
    v_description_template_id integer := 1;
    v_entry_source_id integer := 1;
    v_opening_equity uuid;
    v_sundry_debtors uuid;
    v_sundry_creditors uuid;
    v_salary_payable uuid;

    rec_company RECORD;
    ob_rec RECORD;
    v_transaction_id bigint;
    v_document_number text;
    v_transaction_date timestamp;
    v_entry_type text;
    v_entity_type text;
    v_entity_id uuid;
    v_main_account uuid;
    v_should_insert boolean;
    v_name text;
    v_customer_id uuid;
    v_vendor_id uuid;
    v_employee_id uuid;
    v_account_id uuid;
    v_year_label text;
BEGIN
    -- COA account IDs
    SELECT id INTO v_opening_equity 
      FROM public.chart_of_accounts 
     WHERE account_type_id = (SELECT account_type_id FROM public.chart_of_accounts WHERE name = 'Opening Balance Equity' LIMIT 1)
       AND name = 'Opening Balance Equity'
     LIMIT 1;
    IF v_opening_equity IS NULL THEN
        RAISE EXCEPTION 'Chart of Accounts "Opening Balance Equity" not found!';
    END IF;

	SELECT accounts_receivable_account_id, accounts_payable_account_id, salary_payable_account_id INTO v_sundry_debtors, v_sundry_creditors, v_salary_payable
    FROM public.organization_accounts
    WHERE organization_id = p_organization_id;
  
    IF v_sundry_debtors IS NULL THEN
        RAISE EXCEPTION 'Chart of Accounts "Sundry Debtors" not found!';
    END IF;
    
    IF v_sundry_creditors IS NULL THEN
        RAISE EXCEPTION 'Chart of Accounts "Sundry Creditors" not found!';
    END IF;

    IF v_salary_payable IS NULL THEN
        RAISE EXCEPTION 'Chart of Accounts "Salary Payable" not found!';
    END IF;

    -- Set transaction_date and year label from the finance year
    SELECT start_date, "year" INTO v_transaction_date, v_year_label FROM public.finance_year WHERE id = p_finyear_id;
    IF v_transaction_date IS NULL OR v_year_label IS NULL THEN
        RAISE EXCEPTION 'Finance year with id % not found or year column is NULL!', p_finyear_id;
    END IF;

    -- Create a temporary table to track inserted COA accounts
    CREATE TEMP TABLE IF NOT EXISTS temp_inserted_coa_accounts (account_id uuid PRIMARY KEY);

    -- For each company in the organization, with the selected finance year
    FOR rec_company IN
        SELECT c.id AS company_id
          FROM public.companies c
          JOIN public.company_finance_year cfy ON c.id = cfy.company_id
         WHERE c.organization_id = p_organization_id
           AND cfy.finance_year_id = p_finyear_id
    LOOP
        -- For each opening balance for this organization and year
        FOR ob_rec IN
            SELECT *
              FROM public.opening_balances
             WHERE organization_id = p_organization_id
               AND finyear_id = p_finyear_id
        LOOP
            v_should_insert := false;
            v_name := null;
            v_customer_id := null;
            v_vendor_id := null;
            v_employee_id := null;
            v_account_id := null;

            -- Determine main account and entity type, and check mapping
            IF ob_rec.customer_id IS NOT NULL THEN
                v_entity_type := 'Customer';
                v_entity_id := ob_rec.customer_id;
                v_main_account := v_sundry_debtors;

                -- Check customers.company_id = rec_company.company_id
                SELECT c.name INTO v_name
                  FROM public.customers c
                 WHERE c.id = ob_rec.customer_id AND c.company_id = rec_company.company_id;
                IF v_name IS NOT NULL THEN
                    v_should_insert := true;
                    v_document_number := v_name; -- Only the name, not 'OPENBAL-' || v_name
                    v_customer_id := ob_rec.customer_id;
                END IF;

            ELSIF ob_rec.vendor_id IS NOT NULL THEN
                v_entity_type := 'Vendor';
                v_entity_id := ob_rec.vendor_id;
                v_main_account := v_sundry_creditors;

                SELECT v.name INTO v_name
                  FROM public.vendors v
                 WHERE v.id = ob_rec.vendor_id AND v.company_id = rec_company.company_id;
                IF v_name IS NOT NULL THEN
                    v_should_insert := true;
                    v_document_number := v_name; -- Only the name, not 'OPENBAL-' || v_name
                    v_vendor_id := ob_rec.vendor_id;
                END IF;

            ELSIF ob_rec.employee_id IS NOT NULL THEN
                v_entity_type := 'Employee';
                v_entity_id := ob_rec.employee_id;
                v_main_account := v_salary_payable;

                SELECT e.first_name INTO v_name
                  FROM public.employees e
                 WHERE e.id = ob_rec.employee_id AND e.company_id = rec_company.company_id;
                IF v_name IS NOT NULL THEN
                    v_should_insert := true;
                    v_document_number := v_name; -- Only the name, not 'OPENBAL-' || v_name
                    v_employee_id := ob_rec.employee_id;
                END IF;

            ELSE
                -- COA-only
                v_entity_type := 'COA';
                v_entity_id := ob_rec.account_id;
                v_main_account := ob_rec.account_id;

                -- Get COA name
                SELECT c.name INTO v_name
                  FROM public.chart_of_accounts c
                 WHERE c.id = ob_rec.account_id;
                IF v_name IS NOT NULL THEN
                    v_document_number := v_name; -- Only the name, not 'OPENBAL-' || v_name
                    v_account_id := ob_rec.account_id;
                    -- insert only if this coa id is not already present
                    IF NOT EXISTS (SELECT 1 FROM temp_inserted_coa_accounts WHERE account_id = v_account_id) THEN
                        v_should_insert := true;
                        INSERT INTO temp_inserted_coa_accounts(account_id) VALUES (v_account_id);
                    END IF;
                END IF;
            END IF;

            IF v_should_insert THEN
                -- Insert into transaction_headers
                INSERT INTO public.transaction_headers (
                    company_id, transaction_date, status_id, document_number, description, created_on_utc, created_by, transaction_source_type,
                    customer_id, vendor_id, employee_id, document_id
                )
                VALUES (
                    rec_company.company_id,
                    v_transaction_date,
                    v_status_id,
                    v_document_number,
                    'Opening Balance for ' || v_year_label, -- Only the year label from finance_year
                    v_transaction_date,
                    p_created_by,
                    v_transaction_source_type_id,
                    v_customer_id,
                    v_vendor_id,
                    v_employee_id,
                    v_account_id
                )
                RETURNING id INTO v_transaction_id;

                -- Insert into journal_entries (double-entry)
                INSERT INTO public.journal_entries (
                    transaction_id, transaction_date, amount, entry_type, description_template_id, dynamic_data, entry_source_id, account_id
                ) VALUES (
                    v_transaction_id, v_transaction_date, ob_rec.balance, ob_rec.entry_type, v_description_template_id, '{}'::jsonb, v_entry_source_id, v_main_account
                );

                -- Opening Balance Equity
                IF ob_rec.entry_type = 'D' THEN
                    v_entry_type := 'C';
                ELSE
                    v_entry_type := 'D';
                END IF;
                INSERT INTO public.journal_entries (
                    transaction_id, transaction_date, amount, entry_type, description_template_id, dynamic_data, entry_source_id, account_id
                ) VALUES (
                    v_transaction_id, v_transaction_date, ob_rec.balance, v_entry_type, v_description_template_id, '{}'::jsonb, v_entry_source_id, v_opening_equity
                );
            END IF;
        END LOOP;
    END LOOP;

    DROP TABLE IF EXISTS temp_inserted_coa_accounts;
END;
$procedure$

-- Procedure: upsert_user_permissions
CREATE OR REPLACE PROCEDURE public.upsert_user_permissions(IN p_user_id uuid, IN p_permission_ids uuid[], IN p_organization_id uuid, IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_permission_id uuid;
    v_existing_id int;
    v_existing_deleted bool;
    v_inserted_id int;
BEGIN
    FOR v_permission_id IN SELECT unnest(p_permission_ids) LOOP
        SELECT id, is_deleted INTO v_existing_id, v_existing_deleted
        FROM public.user_permissions
        WHERE user_id = p_user_id
          AND permission_id = v_permission_id
          AND organization_id = p_organization_id
        FOR UPDATE;

        IF v_existing_id IS NOT NULL AND NOT v_existing_deleted THEN
            CONTINUE;
        ELSIF v_existing_id IS NOT NULL AND v_existing_deleted THEN
            UPDATE public.user_permissions
            SET is_deleted = false,
                deleted_on_utc = NULL,
                modified_by = p_created_by,
                modified_on_utc = NOW()
            WHERE id = v_existing_id;
        ELSE
            INSERT INTO public.user_permissions (
                user_id,
                permission_id,
                organization_id,
                created_on_utc,
                created_by,
                is_deleted
            ) VALUES (
                p_user_id,
                v_permission_id,
                p_organization_id,
                NOW(),
                p_created_by,
                false
            ) RETURNING id INTO v_inserted_id;
        END IF;
    END LOOP;
END;
$procedure$

-- Procedure: insert_user_permission
CREATE OR REPLACE PROCEDURE public.insert_user_permission(IN p_user_id uuid, IN p_organization_id uuid, IN p_permission_ids uuid[], IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_permission_id uuid;
    v_existing_id INT;
    v_is_deleted BOOLEAN;
BEGIN
    RAISE NOTICE '▶️ START insert_user_permission for user_id=%, org_id=%, created_by=%, permissions=%',
        p_user_id, p_organization_id, p_created_by, p_permission_ids;

    IF p_user_id IS NULL OR p_organization_id IS NULL OR p_created_by IS NULL THEN
        RAISE EXCEPTION '❌ One of the input parameters is NULL (user_id=%, org_id=%, created_by=%)',
            p_user_id, p_organization_id, p_created_by;
    END IF;

    FOREACH v_permission_id IN ARRAY p_permission_ids
    LOOP
        RAISE NOTICE '🔍 Checking permission_id=% for user_id=% in org_id=%',
            v_permission_id, p_user_id, p_organization_id;

        -- Check if the record exists
        SELECT id, is_deleted
        INTO v_existing_id, v_is_deleted
        FROM public.user_permissions
        WHERE user_id = p_user_id
          AND organization_id = p_organization_id
          AND permission_id = v_permission_id
        LIMIT 1;

        IF FOUND THEN
            RAISE NOTICE '✅ Found existing record with id=%, is_deleted=%', v_existing_id, v_is_deleted;
        ELSE
            RAISE NOTICE '❌ No existing record found for this combination';
        END IF;

        IF FOUND AND v_is_deleted = false THEN
            RAISE NOTICE '⚠️ Permission % already active for user %, skipping insert',
                v_permission_id, p_user_id;

        ELSIF FOUND AND v_is_deleted = true THEN
            UPDATE public.user_permissions
            SET is_deleted = false,
                modified_on_utc = NOW(),
                modified_by = p_created_by,
                deleted_on_utc = NULL
            WHERE id = v_existing_id;

            RAISE NOTICE '♻️ Permission % re-activated for user % (id=%)',
                v_permission_id, p_user_id, v_existing_id;

        ELSE
            RAISE NOTICE '✅ Inserting Permission % assigned to user % (new) org: %', v_permission_id, p_user_id, p_organization_id;
            INSERT INTO public.user_permissions (
                user_id,
                organization_id,
                permission_id,
                created_on_utc,
                created_by,
                is_deleted
            )
            VALUES (
                p_user_id,
                p_organization_id,
                v_permission_id,
                NOW(),
                p_created_by,
                false
            );


        END IF;
    END LOOP;

    RAISE NOTICE '✅ Completed insert_user_permission for user_id=%', p_user_id;
END;
$procedure$

-- Procedure: insert_multiple_bank_statements_by_excel
-- SOURCE
CREATE OR REPLACE PROCEDURE public.insert_multiple_bank_statements_by_excel(IN p_statements jsonb)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    stmt RECORD;
    v_created_by UUID;
BEGIN
    -- Get 'System' user or fallback
    SELECT id INTO v_created_by
    FROM public.users
    WHERE first_name = 'System'
    LIMIT 1;

    IF v_created_by IS NULL THEN
        RAISE NOTICE '⚠️ No System user found. Using NULL created_by.';
    END IF;

    -- Loop through input JSON
    FOR stmt IN
        SELECT * FROM jsonb_to_recordset(p_statements) AS (
            organization_id UUID,
            txn_date TIMESTAMP,
            cheque_number TEXT,
            description TEXT,
            value_date TIMESTAMP,
            branch_code TEXT,
            debit_amount NUMERIC,
            credit_amount NUMERIC,
            balance NUMERIC,
            bank_id UUID,
            created_by UUID
        )
    LOOP
        BEGIN
            -- Check for existing record (ORG + BANK scoped)
            IF NOT EXISTS (
                SELECT 1
                FROM public.bank_statements bs
                WHERE bs.organization_id = stmt.organization_id
                  AND bs.bank_id = stmt.bank_id
                  AND bs.is_deleted = FALSE
                  AND (
                        (stmt.txn_date::time <> '00:00:00'
                            AND bs.txn_date = stmt.txn_date)
                        OR
                        (stmt.txn_date::time = '00:00:00'
                            AND bs.txn_date::date = stmt.txn_date::date)
                      )
                  AND COALESCE(bs.debit_amount, 0) = COALESCE(stmt.debit_amount, 0)
                  AND COALESCE(bs.credit_amount, 0) = COALESCE(stmt.credit_amount, 0)
                  AND COALESCE(bs.cheque_number, '') = COALESCE(stmt.cheque_number, '')
                  AND COALESCE(bs.description, '') = COALESCE(stmt.description, '')
            ) THEN
                -- INSERT
                INSERT INTO public.bank_statements (
                    organization_id,
                    bank_id,
                    txn_date,
                    cheque_number,
                    description,
                    value_date,
                    branch_code,
                    debit_amount,
                    credit_amount,
                    balance,
                    has_reconciled,
                    created_by,
                    created_on_utc,
                    is_deleted
                )
                VALUES (
                    stmt.organization_id,
                    stmt.bank_id,
                    stmt.txn_date,
                    stmt.cheque_number,
                    stmt.description,
                    stmt.value_date,
                    stmt.branch_code,
                    stmt.debit_amount,
                    stmt.credit_amount,
                    stmt.balance,
                    FALSE,
                    COALESCE(stmt.created_by, v_created_by),
                    (CURRENT_TIMESTAMP AT TIME ZONE 'Asia/Kolkata')::timestamp,
                    FALSE
                );

                RAISE NOTICE '✅ Inserted: %, %', stmt.txn_date, stmt.description;

            ELSE
                -- UPDATE existing
                UPDATE public.bank_statements
                SET
                    cheque_number = stmt.cheque_number,
                    value_date = stmt.value_date,
                    branch_code = stmt.branch_code,
                    balance = stmt.balance,
                    modified_by = COALESCE(stmt.created_by, v_created_by),
                    modified_on_utc = (CURRENT_TIMESTAMP AT TIME ZONE 'Asia/Kolkata')::timestamp
                WHERE organization_id = stmt.organization_id
                  AND bank_id = stmt.bank_id
                  AND is_deleted = FALSE
                  AND (
                        (stmt.txn_date::time <> '00:00:00'
                            AND txn_date = stmt.txn_date)
                        OR
                        (stmt.txn_date::time = '00:00:00'
                            AND txn_date::date = stmt.txn_date::date)
                      )
                  AND COALESCE(debit_amount, 0) = COALESCE(stmt.debit_amount, 0)
                  AND COALESCE(credit_amount, 0) = COALESCE(stmt.credit_amount, 0)
                  AND COALESCE(cheque_number, '') = COALESCE(stmt.cheque_number, '')
                  AND COALESCE(description, '') = COALESCE(stmt.description, '');

                RAISE NOTICE '🔄 Updated: %, %', stmt.txn_date, stmt.description;
            END IF;

        EXCEPTION
            WHEN OTHERS THEN
                RAISE EXCEPTION
                    '❌ Error for org=%, txn_date=%, desc=%, Error: %',
                    stmt.organization_id,
                    stmt.txn_date,
                    stmt.description,
                    SQLERRM;
        END;
    END LOOP;

    RAISE NOTICE '🎉 All bank statements processed successfully.';
END;
$procedure$


-- TARGET
CREATE OR REPLACE PROCEDURE public.insert_multiple_bank_statements_by_excel(IN p_statements jsonb)
 LANGUAGE plpgsql
AS $procedure$

DECLARE
    stmt RECORD;
    v_created_by UUID;
BEGIN
    -- Use system user or default to a fallback ID if required
    SELECT id INTO v_created_by
    FROM users
    WHERE first_name = 'System'
    LIMIT 1;

    -- Loop through each bank statement in the JSONB array
    FOR stmt IN
        SELECT * FROM jsonb_to_recordset(p_statements) AS (
            company_id UUID,
            txn_date DATE,
            cheque_number TEXT,
            description TEXT,
            value_date DATE,
            branch_code TEXT,
            debit_amount NUMERIC,
            credit_amount NUMERIC,
            balance NUMERIC,
            bank_id UUID
        )
    LOOP
        BEGIN
            -- Check for existing bank statement with same txn_date and description
            IF NOT EXISTS (
                SELECT 1
                FROM public.bank_statements
                WHERE company_id = stmt.company_id
                  AND bank_id = stmt.bank_id
                  AND txn_date = stmt.txn_date
                  AND description = stmt.description
                  AND is_deleted = false
            ) THEN
                -- Insert new bank statement
                INSERT INTO public.bank_statements (
                    company_id,
                    txn_date,
                    cheque_number,
                    description,
                    value_date,
                    branch_code,
                    debit_amount,
                    credit_amount,
                    balance,
                    bank_id,
                    created_by,
                    created_on_utc,
                    is_deleted,
					has_reconciled
                ) VALUES (
                    stmt.company_id,
                    stmt.txn_date,
                    stmt.cheque_number,
                    stmt.description,
                    stmt.value_date,
                    stmt.branch_code,
                    stmt.debit_amount,
                    stmt.credit_amount,
                    stmt.balance,
                    stmt.bank_id,
                    v_created_by,
                    (CURRENT_TIMESTAMP AT TIME ZONE 'Asia/Kolkata')::timestamp,
                    false,
					false
                );

                RAISE NOTICE 'Inserted bank statement for date: %, company: %', stmt.txn_date, stmt.company_id;
            ELSE
                -- Update the existing statement
                UPDATE public.bank_statements
                SET
                    cheque_number = stmt.cheque_number,
                    value_date = stmt.value_date,
                    branch_code = stmt.branch_code,
                    debit_amount = stmt.debit_amount,
                    credit_amount = stmt.credit_amount,
                    balance = stmt.balance,
                    modified_by = v_created_by,
                    modified_on_utc = (CURRENT_TIMESTAMP AT TIME ZONE 'Asia/Kolkata')::timestamp
                WHERE company_id = stmt.company_id
                  AND bank_id = stmt.bank_id
                  AND txn_date = stmt.txn_date
                  AND description = stmt.description
                  AND is_deleted = false;

                RAISE NOTICE 'Updated existing bank statement for date: %, company: %', stmt.txn_date, stmt.company_id;
            END IF;

        EXCEPTION
            WHEN OTHERS THEN
                RAISE EXCEPTION 'Error in processing statement for txn_date: %, description: %, Error: %', stmt.txn_date, stmt.description, SQLERRM;
        END;
    END LOOP;

    RAISE NOTICE 'All bank statements processed successfully';
END;
$procedure$

-- Procedure: upsert_user_permissions
CREATE OR REPLACE PROCEDURE public.upsert_user_permissions(IN p_user_id uuid, IN p_permission_ids uuid[], IN p_role_ids integer[], IN p_organization_id uuid, IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_permission_id uuid;
    v_role_id int;
    v_existing_id int;
    v_existing_deleted bool;
    v_existing_role_id int;
BEGIN
    -- 0️⃣ Soft-delete permissions NOT in the new list
    UPDATE public.user_permissions
    SET is_deleted = TRUE,
        deleted_on_utc = NOW(),
        modified_by = p_created_by,
        modified_on_utc = NOW()
    WHERE user_id = p_user_id
      AND organization_id = p_organization_id
      AND (p_permission_ids IS NULL OR permission_id <> ALL(p_permission_ids))
      AND is_deleted = FALSE;

    -- 1️⃣ Upsert (reactivate or insert) listed permissions
    FOR v_permission_id IN SELECT unnest(p_permission_ids) LOOP
        SELECT id, is_deleted
        INTO v_existing_id, v_existing_deleted
        FROM public.user_permissions
        WHERE user_id = p_user_id
          AND permission_id = v_permission_id
          AND organization_id = p_organization_id
        FOR UPDATE;

        IF v_existing_id IS NOT NULL AND NOT v_existing_deleted THEN
            CONTINUE;
        ELSIF v_existing_id IS NOT NULL AND v_existing_deleted THEN
            UPDATE public.user_permissions
            SET is_deleted = FALSE,
                deleted_on_utc = NULL,
                modified_by = p_created_by,
                modified_on_utc = NOW()
            WHERE id = v_existing_id;
        ELSE
            INSERT INTO public.user_permissions (
                user_id, permission_id, organization_id,
                created_on_utc, created_by, is_deleted
            ) VALUES (
                p_user_id, v_permission_id, p_organization_id,
                NOW(), p_created_by, false
            );
        END IF;
    END LOOP;

    -- 2️⃣ Soft-delete roles NOT in the new list
    UPDATE public.user_roles
    SET is_deleted = TRUE,
        deleted_on_utc = NOW(),
        modified_by = p_created_by,
        modified_on_utc = NOW()
    WHERE user_id = p_user_id
      AND organization_id = p_organization_id
      AND (p_role_ids IS NULL OR role_id <> ALL(p_role_ids))
      AND is_deleted = FALSE;

    -- 3️⃣ Upsert (reactivate or insert) listed roles
    FOR v_role_id IN SELECT unnest(p_role_ids) LOOP
        SELECT id
        INTO v_existing_role_id
        FROM public.user_roles
        WHERE user_id = p_user_id
          AND role_id = v_role_id
          AND organization_id = p_organization_id;

        IF v_existing_role_id IS NULL THEN
            INSERT INTO public.user_roles (
                user_id, role_id, organization_id,
                created_on_utc, created_by, start_date, is_deleted
            ) VALUES (
                p_user_id, v_role_id, p_organization_id,
                NOW(), p_created_by, NOW(), FALSE
            );
        ELSE
            UPDATE public.user_roles
            SET is_deleted = FALSE,
                deleted_on_utc = NULL,
                modified_by = p_created_by,
                modified_on_utc = NOW()
            WHERE id = v_existing_role_id
              AND is_deleted = TRUE;
        END IF;
    END LOOP;
END;
$procedure$

-- Procedure: upsert_user_permission_template
CREATE OR REPLACE PROCEDURE public.upsert_user_permission_template(IN p_user_id uuid, IN p_permission_template_ids integer[], IN p_created_by uuid, IN p_organization_id uuid DEFAULT NULL::uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_permission_id uuid;
    v_existing_up_id int;
    v_existing_up_deleted boolean;
    v_inserted_up_id int;
    v_org_user_id uuid;
BEGIN
    -- nothing to do if no templates provided
    IF p_permission_template_ids IS NULL OR array_length(p_permission_template_ids, 1) IS NULL THEN
        RETURN;
    END IF;

    ----------------------------------------------------------------
    -- 1) Ensure organization_users row exists for this user + org
    --    (Do this before touching user_permissions)
    ----------------------------------------------------------------
    SELECT id
    INTO v_org_user_id
    FROM public.organization_users
    WHERE user_id = p_user_id
      AND organization_id IS NOT DISTINCT FROM p_organization_id
    FOR UPDATE;

    IF v_org_user_id IS NULL THEN
        INSERT INTO public.organization_users (
            id,
            user_id,
            effective_start_date,
            effective_end_date,
            created_on_utc,
            is_deleted,
            created_by,
            organization_id
        ) VALUES (
            gen_random_uuid(),                -- requires pgcrypto (or replace with uuid_generate_v4())
            p_user_id,
            NOW(),                            -- effective_start_date
            NOW() + INTERVAL '1 year',        -- effective_end_date
            NOW(),                            -- created_on_utc
            false,                            -- is_deleted
            p_created_by,
            COALESCE(p_organization_id, '00000000-0000-0000-0000-000000000000'::uuid)
        )
        RETURNING id INTO v_org_user_id;
    END IF;

    ----------------------------------------------------------------
    -- 2) Upsert user_permissions for permission_ids from templates
    ----------------------------------------------------------------
    FOR v_permission_id IN
        SELECT DISTINCT ptm.permission_id
        FROM public.permission_template_mappings ptm
        WHERE ptm.permission_template_id = ANY (p_permission_template_ids)
    LOOP
        -- Look for an existing user_permissions row for this user, permission and organization.
        SELECT id, is_deleted
        INTO v_existing_up_id, v_existing_up_deleted
        FROM public.user_permissions
        WHERE user_id = p_user_id
          AND permission_id = v_permission_id
          AND organization_id IS NOT DISTINCT FROM p_organization_id
        FOR UPDATE;

        -- If it exists and is active, nothing to do.
        IF v_existing_up_id IS NOT NULL AND NOT v_existing_up_deleted THEN
            CONTINUE;

        -- If it exists and is marked deleted, reactivate it.
        ELSIF v_existing_up_id IS NOT NULL AND v_existing_up_deleted THEN
            UPDATE public.user_permissions
            SET is_deleted = false,
                deleted_on_utc = NULL,
                modified_by = p_created_by,
                modified_on_utc = NOW()
            WHERE id = v_existing_up_id;

        -- Otherwise insert a new row.
        ELSE
            INSERT INTO public.user_permissions (
                user_id,
                permission_id,
                organization_id,
                created_on_utc,
                created_by,
                is_deleted
            ) VALUES (
                p_user_id,
                v_permission_id,
                p_organization_id,
                NOW(),
                p_created_by,
                false
            ) RETURNING id INTO v_inserted_up_id;
        END IF;
    END LOOP;
END;
$procedure$

-- Procedure: insert_into_bank_transfers
CREATE OR REPLACE PROCEDURE public.insert_into_bank_transfers(IN p_company_id uuid, IN p_bank_transfer_id uuid, IN p_transfer_date date, IN p_amount numeric, IN p_description text, IN p_source_account_id uuid, IN p_target_account_id uuid, IN p_mode_of_payment integer, IN p_reference text, IN p_created_by uuid)
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_transfer_number text;
    v_transaction_id bigint;
    v_narration_id bigint;
BEGIN
    -- 1️⃣ Generate transfer number
    v_transfer_number :=
        get_new_transfer_number(p_company_id, p_transfer_date);

    -- 2️⃣ Insert bank transfer
    INSERT INTO public.bank_transfers (
        id,
        company_id,
        source_account_id,
        target_account_id,
        amount,
        transfer_date,
        mode_of_payment,
        reference,
        description,
        is_bulk,
        created_by,
        created_on_utc,
        is_deleted,
        transfer_number
    )
    VALUES (
        p_bank_transfer_id,
        p_company_id,
        p_source_account_id,
        p_target_account_id,
        p_amount,
        p_transfer_date,
        COALESCE(p_mode_of_payment, 0),
        NULLIF(p_reference, ''),
        p_description,
        FALSE,
        p_created_by,
        CURRENT_TIMESTAMP,
        FALSE,
        v_transfer_number
    );

    -- 3️⃣ Insert transaction header
    INSERT INTO public.transaction_headers (
        company_id,
        transaction_date,
        transaction_source_type,
        status_id,
        document_id,
        document_number,
        description,
        created_by,
        created_on_utc
    )
    VALUES (
        p_company_id,
        p_transfer_date,
        19, -- BANK_TRANSFER
        1,
        p_bank_transfer_id,
        v_transfer_number,
        p_description,
        p_created_by,
        CURRENT_TIMESTAMP
    )
    RETURNING id INTO v_transaction_id;

    -- 4️⃣ Create narration ONCE
    INSERT INTO public.journal_narrations (
        transaction_date,
        description_template_id,
        dynamic_data,
        created_on_utc,
        created_by
    )
    VALUES (
        p_transfer_date,
        49, -- BANK_TRANSFER narration template
        jsonb_build_object(
            'type', 'bank_transfer',
            'reference', p_reference
        )::text,
        CURRENT_TIMESTAMP,
        p_created_by
    )
    RETURNING id INTO v_narration_id;

    -- 5️⃣ Credit source account
    INSERT INTO public.journal_entries (
        transaction_id,
        transaction_date,
        account_id,
        amount,
        entry_type,
        entry_source_id,
        journal_narration_id
    )
    VALUES (
        v_transaction_id,
        p_transfer_date,
        p_source_account_id,
        p_amount,
        'C',
        2,
        v_narration_id
    );

    -- 6️⃣ Debit target account
    INSERT INTO public.journal_entries (
        transaction_id,
        transaction_date,
        account_id,
        amount,
        entry_type,
        entry_source_id,
        journal_narration_id
    )
    VALUES (
        v_transaction_id,
        p_transfer_date,
        p_target_account_id,
        p_amount,
        'D',
        2,
        v_narration_id
    );

END;
$procedure$

-- Procedure: update_existing_user_role_permissions
CREATE OR REPLACE PROCEDURE public.update_existing_user_role_permissions(IN p_user_id uuid, IN p_created_by uuid, IN p_organization_id uuid DEFAULT NULL::uuid, IN p_company_id uuid DEFAULT NULL::uuid, IN p_permission_ids uuid[] DEFAULT NULL::uuid[], IN p_role_ids integer[] DEFAULT NULL::integer[])
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_role_permission_ids uuid[];
    v_final_permission_ids uuid[];
BEGIN
    RAISE NOTICE 'Procedure started for user_id=%', p_user_id;

    -- Insert user to organization
    IF p_organization_id IS NOT NULL THEN
        RAISE NOTICE 'Inserting user into organization: %', p_organization_id;

        CALL public.insert_organization_user(
            p_user_id,
            p_created_by,
            p_organization_id
        );
    END IF;

    -- Insert user to company
    IF p_company_id IS NOT NULL THEN
        RAISE NOTICE 'Inserting user into company: %', p_company_id;

        CALL public.insert_company_user(
            p_user_id,
            p_created_by,
            p_company_id
        );
    END IF;

    /* ---------------------------------------------
       1. Fetch permission_ids from role_permissions
       --------------------------------------------- */
    IF p_role_ids IS NOT NULL THEN
        RAISE NOTICE 'Fetching permissions for roles: %', p_role_ids;

        SELECT ARRAY_AGG(DISTINCT rp.permission_id)
        INTO v_role_permission_ids
        FROM public.role_permissions rp
        WHERE rp.role_id = ANY (p_role_ids)
          AND rp.is_deleted = false;

        RAISE NOTICE 'Permissions from roles: %', v_role_permission_ids;
    END IF;

    /* ---------------------------------------------
       2. Merge direct permissions + role permissions
       --------------------------------------------- */
    v_final_permission_ids :=
        ARRAY(
            SELECT DISTINCT unnest(
                COALESCE(p_permission_ids, '{}') ||
                COALESCE(v_role_permission_ids, '{}')
            )
        );

    RAISE NOTICE 'Final permission list: %', v_final_permission_ids;

    /* ---------------------------------------------
       3. Insert permissions to user
       --------------------------------------------- */
    IF v_final_permission_ids IS NOT NULL
       AND array_length(v_final_permission_ids, 1) > 0
       AND p_organization_id IS NOT NULL THEN

        RAISE NOTICE 'Inserting permissions for user into organization %', p_organization_id;

        CALL public.insert_user_permission(
            p_user_id,
            p_organization_id,
            v_final_permission_ids,
            p_created_by
        );
    ELSE
        RAISE NOTICE 'No permissions inserted (empty list or organization missing)';
    END IF;

    /* ---------------------------------------------
       4. Insert user roles
       --------------------------------------------- */
    IF p_role_ids IS NOT NULL THEN
        RAISE NOTICE 'Assigning roles to user: %', p_role_ids;

        CALL public.insert_user_roles(
            p_user_id,
            p_role_ids,
            p_organization_id,
            p_created_by
        );
    END IF;

    RAISE NOTICE 'Procedure completed successfully for user_id=%', p_user_id;
END;
$procedure$

-- Procedure: update_existing_user_role_permissions
CREATE OR REPLACE PROCEDURE public.update_existing_user_role_permissions(IN p_user_id uuid, IN p_created_by uuid, IN p_organization_id uuid DEFAULT NULL::uuid, IN p_company_id uuid DEFAULT NULL::uuid, IN p_role_ids integer[] DEFAULT NULL::integer[])
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_role_permission_ids uuid[];
BEGIN
    RAISE NOTICE 'UPDATE procedure started for user_id=%', p_user_id;

    /* ---------------------------------------------
       Ensure user-organization & company mapping
       --------------------------------------------- */
    IF p_organization_id IS NOT NULL THEN
        RAISE NOTICE 'Ensuring user exists in organization: %', p_organization_id;

        CALL public.insert_organization_user(
            p_user_id,
            p_created_by,
            p_organization_id
        );
    END IF;

    IF p_company_id IS NOT NULL THEN
        RAISE NOTICE 'Ensuring user exists in company: %', p_company_id;

        CALL public.insert_company_user(
            p_user_id,
            p_created_by,
            p_company_id
        );
    END IF;

    /* ---------------------------------------------
       1. Fetch permissions ONLY from roles
       --------------------------------------------- */
    IF p_role_ids IS NOT NULL THEN
        RAISE NOTICE 'Roles received for update: %', p_role_ids;

        SELECT ARRAY_AGG(DISTINCT rp.permission_id)
        INTO v_role_permission_ids
        FROM public.role_permissions rp
        WHERE rp.role_id = ANY (p_role_ids)
          AND rp.is_deleted = false;

        RAISE NOTICE 'Permissions derived from roles: %', v_role_permission_ids;
    ELSE
        RAISE NOTICE 'No roles provided, skipping permission derivation';
    END IF;

    /* ---------------------------------------------
       2. Update user permissions (role-based only)
       --------------------------------------------- */
    IF v_role_permission_ids IS NOT NULL
       AND array_length(v_role_permission_ids, 1) > 0
       AND p_organization_id IS NOT NULL THEN

        RAISE NOTICE 'Updating user permissions using role-based permissions';

        CALL public.insert_user_permission(
            p_user_id,
            p_organization_id,
            v_role_permission_ids,
            p_created_by
        );
    ELSE
        RAISE NOTICE 'No role-based permissions to apply';
    END IF;

    /* ---------------------------------------------
       3. Update user roles
       --------------------------------------------- */
    IF p_role_ids IS NOT NULL THEN
        RAISE NOTICE 'Updating user roles: %', p_role_ids;

        CALL public.insert_user_roles(
            p_user_id,
            p_role_ids,
            p_organization_id,
            p_created_by
        );
    END IF;

    RAISE NOTICE 'UPDATE procedure completed successfully for user_id=%', p_user_id;
END;
$procedure$

-- Procedure: update_existing_users_role_permissions
CREATE OR REPLACE PROCEDURE public.update_existing_users_role_permissions(IN p_user_ids uuid[], IN p_created_by uuid, IN p_organization_id uuid DEFAULT NULL::uuid, IN p_company_id uuid DEFAULT NULL::uuid, IN p_role_ids integer[] DEFAULT NULL::integer[])
 LANGUAGE plpgsql
AS $procedure$
DECLARE
    v_user_id uuid;
    v_role_permission_ids uuid[];
BEGIN
    RAISE NOTICE 'UPDATE procedure started for users=%', p_user_ids;

    /* ---------------------------------------------
       1. Fetch permissions ONLY from roles (once)
       --------------------------------------------- */
    IF p_role_ids IS NOT NULL THEN
        RAISE NOTICE 'Roles received: %', p_role_ids;

        SELECT ARRAY_AGG(DISTINCT rp.permission_id)
        INTO v_role_permission_ids
        FROM public.role_permissions rp
        WHERE rp.role_id = ANY (p_role_ids)
          AND rp.is_deleted = false;

        RAISE NOTICE 'Permissions derived from roles: %', v_role_permission_ids;
    ELSE
        RAISE NOTICE 'No roles provided, skipping permission derivation';
    END IF;

    /* ---------------------------------------------
       2. Loop through each user
       --------------------------------------------- */
    FOREACH v_user_id IN ARRAY p_user_ids
    LOOP
        RAISE NOTICE 'Processing user_id=%', v_user_id;

        -- Ensure user-organization mapping
        IF p_organization_id IS NOT NULL THEN
            CALL public.insert_organization_user(
                v_user_id,
                p_created_by,
                p_organization_id
            );
        END IF;

        -- Ensure user-company mapping
        IF p_company_id IS NOT NULL THEN
            CALL public.insert_company_user(
                v_user_id,
                p_created_by,
                p_company_id
            );
        END IF;

        -- Assign role-based permissions
        IF v_role_permission_ids IS NOT NULL
           AND array_length(v_role_permission_ids, 1) > 0
           AND p_organization_id IS NOT NULL THEN

            CALL public.insert_user_permission(
                v_user_id,
                p_organization_id,
                v_role_permission_ids,
                p_created_by
            );
        END IF;

        -- Assign roles
        IF p_role_ids IS NOT NULL THEN
            CALL public.insert_user_roles(
                v_user_id,
                p_role_ids,
                p_organization_id,
                p_created_by
            );
        END IF;

        RAISE NOTICE 'Completed user_id=%', v_user_id;
    END LOOP;

    RAISE NOTICE 'UPDATE procedure completed for all users';
END;
$procedure$

-- Procedure: add_existing_user_role_permissions
CREATE OR REPLACE PROCEDURE public.add_existing_user_role_permissions(IN p_user_id uuid, IN p_created_by uuid, IN p_organization_id uuid DEFAULT NULL::uuid, IN p_company_id uuid DEFAULT NULL::uuid, IN p_permission_ids uuid[] DEFAULT NULL::uuid[], IN p_role_ids integer[] DEFAULT NULL::integer[])
 LANGUAGE plpgsql
AS $procedure$
BEGIN
    -- Insert user to organization if organization_id is provided
    IF p_organization_id IS NOT NULL THEN
        CALL public.insert_organization_user(p_user_id, p_created_by, p_organization_id);
    END IF;

    -- Insert user to company if company_id is provided
    IF p_company_id IS NOT NULL THEN
        CALL public.insert_company_user(p_user_id, p_created_by, p_company_id);
    END IF;

    -- Insert permissions if both permission_ids array and organization_id are provided
    IF p_permission_ids IS NOT NULL AND p_organization_id IS NOT NULL THEN
        CALL public.insert_user_permission(p_user_id, p_organization_id, p_permission_ids, p_created_by);
    END IF;

    -- Insert roles if role_ids array is provided
    IF p_role_ids IS NOT NULL THEN
        CALL public.insert_user_roles(p_user_id, p_role_ids, p_organization_id, p_created_by);
    END IF;
END;
$procedure$

-- View: vw_permission_hierarchy
WITH RECURSIVE permission_tree AS (
         SELECT p.id,
            p.name,
            p.parent_permission_id,
            p.description,
            1 AS level,
            p.id AS root_permission_id
           FROM permissions p
        UNION ALL
         SELECT c.id,
            c.name,
            c.parent_permission_id,
            c.description,
            (pt.level + 1) AS level,
            pt.root_permission_id
           FROM (permissions c
             JOIN permission_tree pt ON ((c.parent_permission_id = pt.id)))
        )
 SELECT root_permission_id,
    id AS permission_id,
    name AS permission_name,
    parent_permission_id,
    description,
    level
   FROM permission_tree;

-- View: vw_organization_summary
SELECT DISTINCT o.id AS organization_id,
    o.name AS organization_name,
    c.id AS company_id,
    c.name AS company_name,
    u.id AS user_id,
    concat(u.first_name, ' ', u.last_name) AS user_full_name,
    u.email AS user_email,
    u.phone_number AS user_phone,
    'Company User'::text AS user_role_source,
    o.created_on_utc AS organization_created_on
   FROM (((organizations o
     JOIN companies c ON ((c.organization_id = o.id)))
     JOIN company_users cu ON ((cu.company_id = c.id)))
     JOIN users u ON ((u.id = cu.user_id)))
UNION
 SELECT DISTINCT o.id AS organization_id,
    o.name AS organization_name,
    NULL::uuid AS company_id,
    NULL::text AS company_name,
    u.id AS user_id,
    concat(u.first_name, ' ', u.last_name) AS user_full_name,
    u.email AS user_email,
    u.phone_number AS user_phone,
    'Organization User'::text AS user_role_source,
    o.created_on_utc AS organization_created_on
   FROM ((organizations o
     JOIN organization_users ou ON ((ou.organization_id = o.id)))
     JOIN users u ON ((u.id = ou.user_id)));

-- View: transaction_sums_by_party
SELECT th.customer_id,
    th.vendor_id,
    th.employee_id,
    c.name AS customer_name,
    v.name AS vendor_name,
    sum(
        CASE
            WHEN ((je.entry_type = 'C'::bpchar) AND (coa.account_type_id = ANY (ARRAY[4, 14, 15, 19, 20]))) THEN je.amount
            ELSE (0)::numeric
        END) AS total_invoiced,
    sum(
        CASE
            WHEN ((je.entry_type = 'D'::bpchar) AND (coa.account_type_id = ANY (ARRAY[5, 16, 17, 18, 21, 22]))) THEN je.amount
            ELSE (0)::numeric
        END) AS total_billed,
    sum(
        CASE
            WHEN ((je.entry_type = 'C'::bpchar) AND (coa.account_type_id = ANY (ARRAY[8, 9]))) THEN je.amount
            ELSE (0)::numeric
        END) AS total_received,
    sum(
        CASE
            WHEN ((je.entry_type = 'D'::bpchar) AND (coa.account_type_id = ANY (ARRAY[8, 9]))) THEN je.amount
            ELSE (0)::numeric
        END) AS total_paid
   FROM ((((transaction_headers th
     LEFT JOIN customers c ON ((th.customer_id = c.id)))
     LEFT JOIN vendors v ON ((th.vendor_id = v.id)))
     JOIN journal_entries je ON ((je.transaction_id = th.id)))
     JOIN chart_of_accounts coa ON ((je.account_id = coa.id)))
  WHERE ((th.is_deleted = false) AND (je.is_deleted = false) AND (th.company_id = '9891a03a-d80a-430e-ab33-c419f99cffa0'::uuid))
  GROUP BY th.customer_id, th.vendor_id, th.employee_id, c.name, v.name
  ORDER BY COALESCE(c.name, v.name);

-- View: vw_user_permissions_details
SELECT up.id AS user_permission_id,
    u.id AS user_id,
    u.first_name AS user_name,
    p.id AS permission_id,
    p.name AS permission_name,
    o.id AS organization_id,
    o.name AS organization_name,
    o.short_name AS organization_short_name,
    o.phone_number AS organization_phone_number,
    o.email AS organization_email,
    o.gstin AS organization_gstin,
    up.created_on_utc,
    up.created_by,
    up.modified_on_utc,
    up.modified_by,
    up.is_deleted,
    p.deleted_on_utc AS permission_deleted_on_utc,
    up.deleted_on_utc AS user_permission_deleted_on_utc
   FROM (((user_permissions up
     JOIN permissions p ON ((up.permission_id = p.id)))
     JOIN users u ON ((up.user_id = u.id)))
     JOIN organizations o ON ((up.organization_id = o.id)))
  WHERE ((up.is_deleted = false) AND (p.is_deleted = false) AND (o.is_deleted = false));

-- View: transaction_party_view
SELECT th.id AS transaction_id,
    th.company_id,
    th.transaction_date,
    th.document_number,
    th.description,
    th.customer_id,
    c.name AS customer_name,
    th.vendor_id,
    v.name AS vendor_name,
    th.employee_id,
    je.entry_type,
    coa.account_type_id,
    coa.name AS account_name,
    je.amount,
        CASE
            WHEN ((je.entry_type = 'C'::bpchar) AND (coa.account_type_id = ANY (ARRAY[4, 14, 15, 19, 20]))) THEN je.amount
            ELSE (0)::numeric
        END AS invoiced,
        CASE
            WHEN ((je.entry_type = 'C'::bpchar) AND (coa.account_type_id = ANY (ARRAY[8, 9]))) THEN je.amount
            ELSE (0)::numeric
        END AS received,
        CASE
            WHEN ((je.entry_type = 'D'::bpchar) AND (coa.account_type_id = ANY (ARRAY[5, 16, 17, 18, 21, 22]))) THEN je.amount
            ELSE (0)::numeric
        END AS billed,
        CASE
            WHEN ((je.entry_type = 'D'::bpchar) AND (coa.account_type_id = ANY (ARRAY[8, 9]))) THEN je.amount
            ELSE (0)::numeric
        END AS paid
   FROM ((((transaction_headers th
     LEFT JOIN customers c ON ((th.customer_id = c.id)))
     LEFT JOIN vendors v ON ((th.vendor_id = v.id)))
     JOIN journal_entries je ON ((je.transaction_id = th.id)))
     JOIN chart_of_accounts coa ON ((je.account_id = coa.id)))
  WHERE ((th.is_deleted = false) AND (je.is_deleted = false));

-- Trigger: trg_user_permissions_notify
CREATE TRIGGER trg_user_permissions_notify AFTER INSERT OR DELETE OR UPDATE ON user_permissions FOR EACH ROW EXECUTE FUNCTION notify_user_permission_change()

common Schema Comparison Report (QA vs TEST) : 02/04/2026 19:17:17

Features & Navigation