// Centralized SQL strings for workers.

pub const QUERY_UPDATE_MONEY: &str = r#"
SELECT falukant_data.update_money($1, $2, $3);
"#;

pub const QUERY_GET_MONEY: &str = r#"
SELECT money FROM falukant_data.falukant_user WHERE id = $1;
"#;


pub const QUERY_GET_RANDOM_USER: &str = r#"
SELECT id FROM falukant_data.falukant_user ORDER BY RANDOM() LIMIT 1;
"#;

pub const QUERY_GET_RANDOM_INFANT: &str = r#"
SELECT c.id AS character_id, c.user_id, CURRENT_DATE - c.birthdate::date AS age_days
FROM falukant_data."character" c
WHERE c.user_id IS NOT NULL AND c.health > 0 AND CURRENT_DATE - c.birthdate::date <= 730
ORDER BY RANDOM() LIMIT 1;
"#;

pub const QUERY_GET_RANDOM_CITY: &str = r#"
SELECT r.id AS region_id FROM falukant_data.region r JOIN falukant_type.region tr ON r.region_type_id = tr.id WHERE tr.label_tr = 'city' ORDER BY RANDOM() LIMIT 1;
"#;

pub const QUERY_GET_AFFECTED_USERS: &str = r#"
SELECT DISTINCT b.falukant_user_id AS user_id FROM falukant_data.branch b WHERE b.region_id = $1 AND b.falukant_user_id IS NOT NULL;
"#;

pub const QUERY_UPDATE_WEATHER: &str = r#"
WITH all_regions AS (
    SELECT DISTINCT r.id AS region_id FROM falukant_data.region r JOIN falukant_type.region tr ON r.region_type_id = tr.id WHERE tr.label_tr = 'city'
)
INSERT INTO falukant_data.weather (region_id, weather_type_id)
SELECT ar.region_id, (SELECT wt.id FROM falukant_type.weather wt ORDER BY random() + ar.region_id * 0 LIMIT 1) FROM all_regions ar
ON CONFLICT (region_id) DO UPDATE SET weather_type_id = EXCLUDED.weather_type_id;
"#;

pub const QUERY_INSERT_NOTIFICATION: &str = r#"
INSERT INTO falukant_log.notification (user_id, tr, shown, created_at, updated_at)
VALUES ($1, $2, FALSE, NOW(), NOW());
"#;

// Product pricing
pub const QUERY_GET_PRODUCT_COST: &str = r#"
SELECT original_sell_cost, sell_cost FROM falukant_type.product WHERE id = $1;
"#;

pub const QUERY_GET_DIRECTORS: &str = r#"
SELECT d.may_produce, d.may_sell, d.may_start_transport, b.id AS branch_id, fu.id AS falukantUserId, d.id
FROM falukant_data.director d
JOIN falukant_data.falukant_user fu ON fu.id = d.employer_user_id
JOIN falukant_data.character c ON c.id = d.director_character_id
JOIN falukant_data.branch b ON b.region_id = c.region_id AND b.falukant_user_id = fu.id
WHERE current_time BETWEEN '08:00:00' AND '17:00:00';
"#;

pub const QUERY_GET_BEST_PRODUCTION: &str = r#"
SELECT fdu.id falukant_user_id, CAST(fdu.money AS text) AS money, fdu.certificate, ftp.id product_id, ftp.label_tr, fdb.region_id,
(SELECT SUM(quantity) FROM falukant_data.stock fds WHERE fds.branch_id = fdb.id) AS stock_size,
COALESCE((SELECT SUM(COALESCE(fdi.quantity, 0)) FROM falukant_data.stock fds JOIN falukant_data.inventory fdi ON fdi.stock_id = fds.id WHERE fds.branch_id = fdb.id), 0) AS used_in_stock,
(ftp.sell_cost * (fdtpw.worth_percent + (fdk_character.knowledge * 2 + fdk_director.knowledge) / 3) / 100 - 6 * ftp.category) / (300.0 * ftp.production_time) AS worth,
fdb.id AS branch_id, (SELECT COUNT(id) FROM falukant_data.production WHERE branch_id = fdb.id) AS running_productions,
COALESCE((SELECT SUM(COALESCE(fdp.quantity, 0)) quantity FROM falukant_data.production fdp WHERE fdp.branch_id = fdb.id), 0) AS running_productions_quantity
FROM falukant_data.director fdd
JOIN falukant_data.character fdc ON fdc.id = fdd.director_character_id
JOIN falukant_data.falukant_user fdu ON fdd.employer_user_id = fdu.id
JOIN falukant_data.character user_character ON user_character.user_id = fdu.id
JOIN falukant_data.branch fdb ON fdb.falukant_user_id = fdu.id AND fdb.region_id = fdc.region_id
JOIN falukant_data.town_product_worth fdtpw ON fdtpw.region_id = fdb.region_id
JOIN falukant_data.knowledge fdk_character ON fdk_character.product_id = fdtpw.product_id AND fdk_character.character_id = user_character.id
JOIN falukant_data.knowledge fdk_director ON fdk_director.product_id = fdtpw.product_id AND fdk_director.character_id = fdd.director_character_id
JOIN falukant_type.product ftp ON ftp.id = fdtpw.product_id AND ftp.category <= fdu.certificate
WHERE fdd.id = $1 AND fdb.id = $2 ORDER BY worth DESC LIMIT 1;
"#;

pub const QUERY_INSERT_PRODUCTION: &str = r#"
INSERT INTO falukant_data.production (branch_id, product_id, quantity, weather_type_id) VALUES ($1, $2, $3, (SELECT weather_type_id FROM falukant_data.weather WHERE region_id = $4));
"#;

// Character creation related queries (missing from earlier extraction)
pub const QUERY_IS_PREVIOUS_DAY_CHARACTER_CREATED: &str = r#"
        SELECT created_at
        FROM falukant_data."character"
        WHERE user_id IS NULL
            AND created_at::date = CURRENT_DATE
        ORDER BY created_at DESC
        LIMIT 1;
"#;

pub const QUERY_GET_TOWN_REGION_IDS: &str = r#"
        SELECT fdr.id
        FROM falukant_data.region fdr
        JOIN falukant_type.region ftr ON fdr.region_type_id = ftr.id
        WHERE ftr.label_tr = 'city';
"#;

pub const QUERY_LOAD_FIRST_NAMES: &str = r#"
        SELECT id, gender
        FROM falukant_predefine.firstname;
"#;

pub const QUERY_LOAD_LAST_NAMES: &str = r#"
        SELECT id
        FROM falukant_predefine.lastname;
"#;

pub const QUERY_INSERT_CHARACTER: &str = r#"
        INSERT INTO falukant_data.character(
                user_id,
                region_id,
                first_name,
                last_name,
                birthdate,
                gender,
                created_at,
                updated_at,
                title_of_nobility
        ) VALUES (
                NULL,
                $1,
                $2,
                $3,
                NOW(),
                $4,
                NOW(),
                NOW(),
                $5
        );
"#;

pub const QUERY_GET_ELIGIBLE_NPC_FOR_DEATH: &str = r#"
        WITH aged AS (
            SELECT
                c.id,
                (current_date - c.birthdate::date) AS age,
                c.user_id
            FROM
                falukant_data.character c
            WHERE
                c.user_id IS NULL
                AND (current_date - c.birthdate::date) > 60
        ),
        always_sel AS (
            SELECT *
            FROM aged
            WHERE age > 85
        ),
        random_sel AS (
            SELECT *
            FROM aged
            WHERE age <= 85
            ORDER BY random()
            LIMIT 10
        )
    SELECT *
    FROM always_sel
    UNION ALL
    SELECT *
    FROM random_sel;
"#;

pub const QUERY_MARK_CHARACTER_DECEASED: &str = r#"
    DELETE FROM falukant_data.character
     WHERE id = $1;
"#;

pub const QUERY_GET_BRANCH_CAPACITY: &str = r#"
SELECT (SELECT SUM(quantity) FROM falukant_data.stock fds WHERE fds.branch_id = $1) AS stock_size,
COALESCE((SELECT SUM(COALESCE(fdi.quantity, 0)) FROM falukant_data.stock fds JOIN falukant_data.inventory fdi ON fdi.stock_id = fds.id WHERE fds.branch_id = $1), 0) AS used_in_stock,
(SELECT COUNT(id) FROM falukant_data.production WHERE branch_id = $1) AS running_productions,
COALESCE((SELECT SUM(COALESCE(fdp.quantity, 0)) quantity FROM falukant_data.production fdp WHERE fdp.branch_id = $1), 0) AS running_productions_quantity;
"#;

pub const QUERY_GET_INVENTORY: &str = r#"
SELECT i.id, i.product_id, i.quantity, i.quality, p.sell_cost, fu.id AS user_id, b.region_id, b.id AS branch_id, COALESCE(tpw.worth_percent, 100.0) AS worth_percent
FROM falukant_data.inventory i
JOIN falukant_data.stock s ON s.id = i.stock_id
JOIN falukant_data.branch b ON b.id = s.branch_id
JOIN falukant_data.falukant_user fu ON fu.id = b.falukant_user_id
JOIN falukant_data.director d ON d.employer_user_id = fu.id
JOIN falukant_type.product p ON p.id = i.product_id
LEFT JOIN falukant_data.town_product_worth tpw ON tpw.region_id = b.region_id AND tpw.product_id = i.product_id
WHERE d.id = $1 AND b.id = $2;
"#;

pub const QUERY_REMOVE_INVENTORY: &str = r#"
DELETE FROM falukant_data.inventory WHERE id = $1;
"#;

pub const QUERY_ADD_SELL_LOG: &str = r#"
INSERT INTO falukant_log.sell (region_id, product_id, quantity, seller_id) VALUES ($1, $2, $3, $4)
ON CONFLICT (region_id, product_id, seller_id) DO UPDATE SET quantity = falukant_log.sell.quantity + EXCLUDED.quantity;
"#;
pub const QUERY_GET_ARRIVED_TRANSPORTS: &str = r#"
SELECT
    t.id,
    t.product_id,
    t.size,
    t.vehicle_id,
    t.source_region_id,
    t.target_region_id,
    b_target.id AS target_branch_id,
    b_source.id AS source_branch_id,
    rd.distance AS distance,
    v.falukant_user_id AS user_id
FROM falukant_data.transport AS t
JOIN falukant_data.vehicle AS v ON v.id = t.vehicle_id
JOIN falukant_type.vehicle AS vt ON vt.id = v.vehicle_type_id
JOIN falukant_data.region_distance AS rd ON ((rd.source_region_id = t.source_region_id AND rd.target_region_id = t.target_region_id) OR (rd.source_region_id = t.target_region_id AND rd.target_region_id = t.source_region_id)) AND (rd.transport_mode = vt.transport_mode OR rd.transport_mode IS NULL)
LEFT JOIN falukant_data.branch AS b_target ON b_target.region_id = t.target_region_id AND b_target.falukant_user_id = v.falukant_user_id
LEFT JOIN falukant_data.branch AS b_source ON b_source.region_id = t.source_region_id AND b_source.falukant_user_id = v.falukant_user_id
WHERE vt.speed > 0 AND t.created_at + (rd.distance / vt.speed::double precision) * INTERVAL '1 minute' <= NOW();
"#;

pub const QUERY_GET_AVAILABLE_STOCKS: &str = r#"
SELECT
    stock.id,
    stock.quantity AS total_capacity,
    (
        SELECT COALESCE(SUM(inventory.quantity), 0)
        FROM falukant_data.inventory
        WHERE inventory.stock_id = stock.id
    ) AS filled
FROM falukant_data.stock stock
JOIN falukant_data.branch branch
    ON stock.branch_id = branch.id
WHERE branch.id = $1
ORDER BY total_capacity DESC;
"#;

pub const QUERY_INSERT_INVENTORY: &str = r#"
INSERT INTO falukant_data.inventory (stock_id, product_id, quantity, quality, produced_at)
VALUES ($1, $2, $3, $4, NOW())
RETURNING id;
"#;

pub const QUERY_UPDATE_INVENTORY_BY_STOCK_PRODUCT: &str = r#"
UPDATE falukant_data.inventory
   SET quantity = quantity + $3,
       quality = LEAST(
           100,
           ROUND(
               ((quantity * quality) + ($3 * $4))::numeric / NULLIF(quantity + $3, 0)
           )
       )
 WHERE stock_id = $1 AND product_id = $2
 RETURNING id;
"#;

pub const QUERY_UPDATE_VEHICLE_AFTER_TRANSPORT: &str = r#"
UPDATE falukant_data.vehicle SET region_id = $2, condition = GREATEST(0, condition - $3::int), available_from = NOW(), updated_at = NOW() WHERE id = $1;
"#;

pub const QUERY_DELETE_TRANSPORT: &str = r#"
DELETE FROM falukant_data.transport WHERE id = $1;
"#;

pub const QUERY_UPDATE_TRANSPORT_SIZE: &str = r#"
UPDATE falukant_data.transport
   SET size = $2,
       updated_at = NOW()
 WHERE id = $1;
"#;

pub const QUERY_GET_REGION_WORTH_FOR_PRODUCT: &str = r#"
SELECT tpw.region_id, tpw.product_id, tpw.worth_percent FROM falukant_data.town_product_worth tpw JOIN falukant_data.branch b ON b.region_id = tpw.region_id WHERE b.falukant_user_id = $1 AND tpw.product_id = $2;
"#;

// Political offices and cumulative tax
pub const QUERY_GET_USER_OFFICES: &str = r#"
SELECT po.id AS office_id, pot.name AS office_name, po.region_id, rt.label_tr AS region_type
FROM falukant_data.political_office po
JOIN falukant_type.political_office_type pot ON pot.id = po.office_type_id
JOIN falukant_data.region r ON r.id = po.region_id
JOIN falukant_type.region rt ON rt.id = r.region_type_id
JOIN falukant_data.character ch ON ch.id = po.character_id
WHERE ch.user_id = $1
    AND (po.created_at + (pot.term_length * INTERVAL '1 day')) > NOW();
"#;

pub const QUERY_CUMULATIVE_TAX_NO_EXEMPT: &str = r#"
WITH RECURSIVE ancestors AS (
    SELECT id, parent_id, COALESCE(tax_percent,0.0) AS tax_percent FROM falukant_data.region WHERE id = $1
    UNION ALL
    SELECT r.id, r.parent_id, COALESCE(r.tax_percent,0.0) FROM falukant_data.region r JOIN ancestors a ON r.id = a.parent_id
)
SELECT COALESCE(SUM(tax_percent),0.0) AS total_percent FROM ancestors;
"#;

pub const QUERY_CUMULATIVE_TAX_WITH_EXEMPT: &str = r#"
WITH RECURSIVE ancestors AS (
    SELECT r.id, r.parent_id, CASE WHEN rt.label_tr = ANY($2::text[]) THEN 0.0 ELSE COALESCE(r.tax_percent,0.0) END AS tax_percent
    FROM falukant_data.region r JOIN falukant_type.region rt ON rt.id = r.region_type_id WHERE r.id = $1
    UNION ALL
    SELECT r.id, r.parent_id, CASE WHEN rt.label_tr = ANY($2::text[]) THEN 0.0 ELSE COALESCE(r.tax_percent,0.0) END
    FROM falukant_data.region r JOIN falukant_type.region rt ON rt.id = r.region_type_id JOIN ancestors a ON r.id = a.parent_id
)
SELECT COALESCE(SUM(tax_percent),0.0) AS total_percent FROM ancestors;
"#;

pub const QUERY_GET_TRANSPORT_VEHICLES_FOR_ROUTE: &str = r#"
SELECT v.id AS vehicle_id, vt.capacity AS capacity
FROM falukant_data.vehicle v
JOIN falukant_type.vehicle vt ON vt.id = v.vehicle_type_id
JOIN falukant_data.region_distance rd ON ((rd.source_region_id = v.region_id AND rd.target_region_id = $3) OR (rd.source_region_id = $3 AND rd.target_region_id = v.region_id)) AND (rd.transport_mode = vt.transport_mode OR rd.transport_mode IS NULL)
WHERE v.falukant_user_id = $1 AND v.region_id = $2;
"#;

pub const QUERY_INSERT_TRANSPORT: &str = r#"
INSERT INTO falukant_data.transport (source_region_id, target_region_id, product_id, size, vehicle_id, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, NOW(), NOW());
"#;

pub const QUERY_INSERT_EMPTY_TRANSPORT: &str = r#"
INSERT INTO falukant_data.transport (source_region_id, target_region_id, product_id, size, vehicle_id, created_at, updated_at) VALUES ($1, $2, NULL, 0, $3, NOW(), NOW());
"#;

pub const QUERY_GET_USER_BRANCHES: &str = r#"
SELECT DISTINCT b.region_id, b.id AS branch_id FROM falukant_data.branch b WHERE b.falukant_user_id = $1 AND b.region_id != $2;
"#;

pub const QUERY_GET_FREE_VEHICLES_IN_REGION: &str = r#"
SELECT v.id AS vehicle_id, vt.capacity AS capacity FROM falukant_data.vehicle v JOIN falukant_type.vehicle vt ON vt.id = v.vehicle_type_id WHERE v.falukant_user_id = $1 AND v.region_id = $2 AND v.id NOT IN (SELECT DISTINCT t.vehicle_id FROM falukant_data.transport t WHERE t.vehicle_id IS NOT NULL);
"#;

pub const QUERY_GET_SALARY_TO_PAY: &str = r#"
SELECT d.id, d.employer_user_id, d.income FROM falukant_data.director d WHERE DATE(d.last_salary_payout) < DATE(NOW());
"#;

pub const QUERY_SET_SALARY_PAYED: &str = r#"
UPDATE falukant_data.director SET last_salary_payout = NOW() WHERE id = $1;
"#;

pub const QUERY_UPDATE_SATISFACTION: &str = r#"
WITH new_sats AS (
    SELECT d.id, ROUND(d.income::numeric / (c.title_of_nobility * POWER(1.231, AVG(k.knowledge) / 1.5)) * 100) AS new_satisfaction
    FROM falukant_data.director d
    JOIN falukant_data.knowledge k ON d.director_character_id = k.character_id
    JOIN falukant_data.character c ON c.id = d.director_character_id
    GROUP BY d.id, c.title_of_nobility, d.income
)
UPDATE falukant_data.director dir SET satisfaction = ns.new_satisfaction FROM new_sats ns WHERE dir.id = ns.id AND dir.satisfaction IS DISTINCT FROM ns.new_satisfaction RETURNING dir.employer_user_id;
"#;

pub const QUERY_GET_DIRECTOR_USER: &str = r#"
SELECT fu.id AS falukant_user_id FROM falukant_data.director d JOIN falukant_data.falukant_user fu ON fu.id = d.employer_user_id WHERE d.id = $1 LIMIT 1;
"#;

pub const QUERY_COUNT_VEHICLES_IN_BRANCH_REGION: &str = r#"
SELECT COUNT(v.id) AS cnt FROM falukant_data.vehicle v WHERE v.falukant_user_id = $1 AND v.region_id = $2;
"#;

pub const QUERY_COUNT_VEHICLES_IN_REGION: &str = r#"
SELECT COUNT(v.id) AS cnt FROM falukant_data.vehicle v WHERE v.falukant_user_id = $1 AND v.region_id = $2;
"#;

pub const QUERY_CHECK_ROUTE: &str = r#"
SELECT 1 FROM falukant_data.region_distance rd WHERE (rd.source_region_id = $1 AND rd.target_region_id = $2) OR (rd.source_region_id = $2 AND rd.target_region_id = $1) LIMIT 1;
"#;

pub const QUERY_GET_BRANCH_REGION: &str = r#"
SELECT region_id FROM falukant_data.branch WHERE id = $1 LIMIT 1;
"#;

pub const QUERY_GET_AVERAGE_WORTH: &str = r#"
SELECT AVG(tpw.worth_percent) AS avg_worth FROM falukant_data.town_product_worth tpw WHERE tpw.product_id = $1 AND tpw.region_id IN (SELECT region_id FROM falukant_data.branch WHERE falukant_user_id = $2);
"#;

pub const QUERY_UPDATE_INVENTORY_QTY: &str = r#"
UPDATE falukant_data.inventory SET quantity = $1 WHERE id = $2;
"#;

pub const QUERY_GET_USER_STOCKS: &str = r#"
SELECT s.id AS stock_id, s.quantity AS current_capacity
FROM falukant_data.stock s
JOIN falukant_data.branch b ON s.branch_id = b.id
WHERE b.falukant_user_id = $1;
"#;

pub const QUERY_UPDATE_STOCK_CAPACITY: &str = r#"
UPDATE falukant_data.stock
     SET quantity = GREATEST(1, ROUND(quantity * (1 + $1 / 100.0)))
 WHERE id = $2;
"#;

pub const QUERY_GET_REGION_STOCKS: &str = r#"
SELECT s.id AS stock_id, s.quantity AS current_capacity
FROM falukant_data.stock s
JOIN falukant_data.branch b ON s.branch_id = b.id
WHERE b.region_id = $1;
"#;

pub const QUERY_UPDATE_STOCK_CAPACITY_REGIONAL: &str = r#"
UPDATE falukant_data.stock
     SET quantity = GREATEST(1, ROUND(quantity * (1 + $1 / 100.0)))
 WHERE id = $2;
"#;

// Stockage manager specific queries
pub const QUERY_GET_TOWNS: &str = r#"
        SELECT fdr.id
            FROM falukant_data.region fdr
            JOIN falukant_type.region ftr
                ON ftr.id = fdr.region_type_id
         WHERE ftr.label_tr = 'city';
"#;

pub const QUERY_INSERT_STOCK: &str = r#"
        INSERT INTO falukant_data.buyable_stock (region_id, stock_type_id, quantity)
        SELECT
                $1 AS region_id,
                s.id AS stock_type_id,
                GREATEST(1, ROUND(RANDOM() * 5 * COUNT(br.id))) AS quantity
            FROM falukant_data.branch AS br
            CROSS JOIN falukant_type.stock AS s
         WHERE br.region_id = $1
         GROUP BY s.id
         ORDER BY RANDOM()
         LIMIT GREATEST(
                 ROUND(RANDOM() * (SELECT COUNT(id) FROM falukant_type.stock)),
                 1
         );
"#;

pub const QUERY_CLEANUP_STOCK: &str = r#"
        DELETE FROM falukant_data.buyable_stock
         WHERE quantity <= 0;
"#;

pub const QUERY_GET_REGION_USERS: &str = r#"
        SELECT c.user_id
            FROM falukant_data.character c
         WHERE c.region_id = $1
             AND c.user_id IS NOT NULL;
"#;

pub const QUERY_GET_REGION_HOUSES: &str = r#"
SELECT uh.id AS house_id, uh.roof_condition, uh.floor_condition, uh.wall_condition, uh.window_condition
FROM falukant_data.user_house uh
JOIN falukant_data.character c ON c.user_id = uh.user_id
WHERE c.region_id = $1
    AND uh.house_type_id NOT IN (
            SELECT id FROM falukant_type.house h WHERE h.label_tr = 'under_bridge'
    );
"#;

// House worker queries
pub const QUERY_GET_NEW_HOUSE_DATA: &str = r#"
    SELECT
        h.id AS house_id
    FROM
        falukant_type.house AS h
    WHERE
        random() < 0.0001
        AND label_tr <> 'under_bridge';
"#;

pub const QUERY_ADD_NEW_BUYABLE_HOUSE: &str = r#"
    INSERT INTO falukant_data.buyable_house (house_type_id)
    VALUES ($1);
"#;

pub const QUERY_UPDATE_BUYABLE_HOUSE_STATE: &str = r#"
    UPDATE falukant_data.buyable_house
       SET roof_condition   = ROUND(roof_condition   - random() * (3 + 0 * id)),
           floor_condition  = ROUND(floor_condition  - random() * (3 + 0 * id)),
           wall_condition   = ROUND(wall_condition   - random() * (3 + 0 * id)),
           window_condition = ROUND(window_condition - random() * (3 + 0 * id));
"#;

pub const QUERY_UPDATE_USER_HOUSE_STATE: &str = r#"
    UPDATE falukant_data.user_house
       SET roof_condition   = ROUND(roof_condition   - random() * (3 + 0 * id)),
           floor_condition  = ROUND(floor_condition  - random() * (3 + 0 * id)),
           wall_condition   = ROUND(wall_condition   - random() * (3 + 0 * id)),
           window_condition = ROUND(window_condition - random() * (3 + 0 * id))
     WHERE house_type_id NOT IN (
           SELECT id
             FROM falukant_type.house h
            WHERE h.label_tr = 'under_bridge'
     );
"#;

pub const QUERY_UPDATE_HOUSE_QUALITY: &str = r#"
UPDATE falukant_data.user_house
     SET roof_condition   = GREATEST(0, LEAST(100, roof_condition + $1)),
             floor_condition  = GREATEST(0, LEAST(100, floor_condition + $1)),
             wall_condition   = GREATEST(0, LEAST(100, wall_condition + $1)),
             window_condition = GREATEST(0, LEAST(100, window_condition + $1))
 WHERE id = $2;
"#;

pub const QUERY_CHANGE_WEATHER: &str = r#"
UPDATE falukant_data.weather
SET weather_type_id = (
        SELECT id FROM falukant_type.weather ORDER BY RANDOM() LIMIT 1
)
WHERE region_id = $1;
"#;

pub const QUERY_GET_RANDOM_CHARACTER: &str = r#"
SELECT id, health
FROM falukant_data."character"
WHERE user_id = $1 AND health > 0
ORDER BY RANDOM() LIMIT 1;
"#;

pub const QUERY_UPDATE_HEALTH: &str = r#"
UPDATE falukant_data."character" SET health = $1 WHERE id = $2;
"#;

pub const QUERY_GET_REGION_CHARACTERS: &str = r#"
SELECT id, health FROM falukant_data."character" WHERE region_id = $1 AND health > 0;
"#;

pub const QUERY_DELETE_DIRECTOR: &str = r#"
DELETE FROM falukant_data.director WHERE director_character_id = $1 RETURNING employer_user_id;
"#;

pub const QUERY_DELETE_RELATIONSHIP: &str = r#"
WITH deleted AS (
    DELETE FROM falukant_data.relationship
     WHERE character1_id = $1 OR character2_id = $1
    RETURNING CASE WHEN character1_id = $1 THEN character2_id ELSE character1_id END AS related_character_id, relationship_type_id
)
SELECT c.user_id AS related_user_id FROM deleted d JOIN falukant_data.character c ON c.id = d.related_character_id;
"#;

pub const QUERY_GET_USER_ID: &str = r#"
SELECT user_id FROM falukant_data.character WHERE id = $1;
"#;

pub const QUERY_DELETE_CHILD_RELATION: &str = r#"
WITH deleted AS (
    DELETE FROM falukant_data.child_relation WHERE child_character_id = $1 RETURNING father_character_id, mother_character_id
)
SELECT cf.user_id AS father_user_id, cm.user_id AS mother_user_id FROM deleted d JOIN falukant_data.character cf ON cf.id = d.father_character_id JOIN falukant_data.character cm ON cm.id = d.mother_character_id;
"#;

pub const QUERY_DELETE_CHARACTER: &str = r#"
DELETE FROM falukant_data.character WHERE id = $1;
"#;

pub const QUERY_GET_HEIR: &str = r#"
SELECT child_character_id FROM falukant_data.child_relation WHERE father_character_id = $1 OR mother_character_id = $1 ORDER BY (is_heir IS TRUE) DESC, updated_at DESC LIMIT 1;
"#;

pub const QUERY_SET_CHARACTER_USER: &str = r#"
UPDATE falukant_data.character SET user_id = $1, updated_at = NOW() WHERE id = $2;
"#;

pub const QUERY_GET_CURRENT_MONEY: &str = r#"
SELECT money FROM falukant_data.falukant_user WHERE id = $1;
"#;

pub const QUERY_GET_HOUSE_VALUE: &str = r#"
SELECT COALESCE(SUM(h.cost), 0) AS sum FROM falukant_data.user_house AS uh JOIN falukant_type.house AS h ON uh.house_type_id = h.id WHERE uh.user_id = $1;
"#;

pub const QUERY_GET_SETTLEMENT_VALUE: &str = r#"
SELECT COALESCE(SUM(b.base_cost), 0) AS sum FROM falukant_data.branch AS br JOIN falukant_type.branch AS b ON br.branch_type_id = b.id WHERE br.falukant_user_id = $1;
"#;

pub const QUERY_GET_INVENTORY_VALUE: &str = r#"
SELECT COALESCE(SUM(i.quantity * p.sell_cost), 0) AS sum FROM falukant_data.inventory AS i JOIN falukant_type.product AS p ON i.product_id = p.id JOIN falukant_data.stock AS s ON i.stock_id = s.id JOIN falukant_data.branch AS br ON s.branch_id = br.id WHERE br.falukant_user_id = $1;
"#;

pub const QUERY_GET_CREDIT_DEBT: &str = r#"
SELECT COALESCE(SUM(remaining_amount), 0) AS sum FROM falukant_data.credit WHERE falukant_user_id = $1;
"#;

pub const QUERY_COUNT_CHILDREN: &str = r#"
SELECT COUNT(*) AS cnt FROM falukant_data.child_relation WHERE (father_character_id = $1 OR mother_character_id = $1) AND child_character_id != $2;
"#;

// user_character worker queries
pub const QUERY_GET_USERS_TO_UPDATE: &str = r#"
        SELECT id, CURRENT_DATE - birthdate::date AS age, health
        FROM falukant_data."character"
        WHERE user_id IS NOT NULL;
"#;

// politics worker queries
pub const QUERY_COUNT_OFFICES_PER_REGION: &str = r#"
        WITH
        seats_per_region AS (
                SELECT
                        pot.id               AS office_type_id,
                        rt.id                AS region_id,
                        pot.seats_per_region AS seats_total
                FROM falukant_type.political_office_type AS pot
                JOIN falukant_type.region AS rt
                    ON pot.region_type = rt.label_tr
        ),
        occupied AS (
                SELECT
                        po.office_type_id,
                        po.region_id,
                        COUNT(*) AS occupied_count
                FROM falukant_data.political_office AS po
                GROUP BY po.office_type_id, po.region_id
        ),
        combined AS (
                SELECT
                        spr.region_id,
                        spr.seats_total                      AS required_count,
                        COALESCE(o.occupied_count, 0)       AS occupied_count
                FROM seats_per_region AS spr
                LEFT JOIN occupied AS o
                    ON spr.office_type_id = o.office_type_id
                 AND spr.region_id      = o.region_id
        )
        SELECT
                region_id,
                SUM(required_count) AS required_count,
                SUM(occupied_count) AS occupied_count
        FROM combined
        GROUP BY region_id;
"#;

pub const QUERY_FIND_OFFICE_GAPS: &str = r#"
        WITH
        seats AS (
                SELECT
                        pot.id               AS office_type_id,
                        rt.id                AS region_id,
                        pot.seats_per_region AS seats_total
                FROM falukant_type.political_office_type AS pot
                JOIN falukant_type.region AS rt
                    ON pot.region_type = rt.label_tr
        ),
        occupied AS (
                SELECT
                        po.office_type_id,
                        po.region_id,
                        COUNT(*) AS occupied_count
                FROM falukant_data.political_office AS po
                GROUP BY po.office_type_id, po.region_id
        )
        SELECT
                s.office_type_id,
                s.region_id,
                (s.seats_total - COALESCE(o.occupied_count, 0)) AS gaps
        FROM seats AS s
        LEFT JOIN occupied AS o
            ON s.office_type_id = o.office_type_id
         AND s.region_id      = o.region_id
        WHERE (s.seats_total - COALESCE(o.occupied_count, 0)) > 0;
"#;

pub const QUERY_SELECT_NEEDED_ELECTIONS: &str = r#"
        WITH
        target_date AS (
            SELECT NOW()::date AS election_date
        ),
        expired_today AS (
            DELETE FROM falukant_data.political_office AS po
            USING falukant_type.political_office_type AS pot
            WHERE po.office_type_id = pot.id
                AND (po.created_at + (pot.term_length * INTERVAL '1 day'))::date
                            = (SELECT election_date FROM target_date)
            RETURNING
                pot.id       AS office_type_id,
                po.region_id AS region_id
        ),
        gaps_per_region AS (
            SELECT
                office_type_id,
                region_id,
                COUNT(*) AS gaps
            FROM expired_today
            GROUP BY office_type_id, region_id
        ),
        to_schedule AS (
            SELECT
                g.office_type_id,
                g.region_id,
                g.gaps,
                td.election_date
            FROM gaps_per_region AS g
            CROSS JOIN target_date AS td
            WHERE NOT EXISTS (
                SELECT 1
                    FROM falukant_data.election AS e
                 WHERE e.office_type_id = g.office_type_id
                     AND e.region_id      = g.region_id
                     AND e.date::date     = td.election_date
            )
        ),
        new_elections AS (
            INSERT INTO falukant_data.election
                (office_type_id, date, posts_to_fill, created_at, updated_at, region_id)
            SELECT
                ts.office_type_id,
                ts.election_date,
                ts.gaps,
                NOW(),
                NOW(),
                ts.region_id
            FROM to_schedule AS ts
            RETURNING
                id         AS election_id,
                region_id,
                posts_to_fill
        )
        SELECT
            ne.election_id,
            ne.region_id,
            ne.posts_to_fill
        FROM new_elections AS ne
        ORDER BY ne.region_id, ne.election_id;
"#;

pub const QUERY_INSERT_CANDIDATES: &str = r#"
        INSERT INTO falukant_data.candidate
                (election_id, character_id, created_at, updated_at)
        SELECT
                $1    AS election_id,
                sub.id AS character_id,
                NOW() AS created_at,
                NOW() AS updated_at
        FROM (
                WITH RECURSIVE region_tree AS (
                        SELECT r.id
                            FROM falukant_data.region AS r
                         WHERE r.id = $2
                        UNION ALL
                        SELECT r2.id
                            FROM falukant_data.region AS r2
                            JOIN region_tree AS rt
                                ON r2.parent_id = rt.id
                )
                SELECT ch.id
                    FROM falukant_data.character AS ch
                    JOIN region_tree AS rt2
                        ON ch.region_id = rt2.id
                 WHERE ch.user_id IS NULL
                     AND ch.birthdate <= NOW() - INTERVAL '21 days'
                     AND ch.title_of_nobility IN (
                                 SELECT id
                                     FROM falukant_type.title
                                    WHERE label_tr != 'noncivil'
                             )
                 ORDER BY RANDOM()
                 LIMIT ($3 * 2)
        ) AS sub(id);
"#;

pub const QUERY_SELECT_ELECTIONS_NEEDING_CANDIDATES: &str = r#"
        SELECT
            e.id         AS election_id,
            e.region_id  AS region_id,
            e.posts_to_fill
        FROM falukant_data.election AS e
        WHERE e.region_id IS NOT NULL
            AND e.posts_to_fill > 0
            AND e.date::date >= CURRENT_DATE
            AND NOT EXISTS (
                        SELECT 1
                            FROM falukant_data.candidate AS c
                         WHERE c.election_id = e.id
                    );
"#;

pub const QUERY_PROCESS_EXPIRED_AND_FILL: &str = r#"
        WITH
        expired_offices AS (
                DELETE FROM falukant_data.political_office AS po
                USING falukant_type.political_office_type AS pot
                WHERE po.office_type_id = pot.id
                    AND (po.created_at + (pot.term_length * INTERVAL '1 day')) <= NOW()
                RETURNING
                        pot.id       AS office_type_id,
                        po.region_id AS region_id
        ),
        distinct_types AS (
                SELECT DISTINCT office_type_id, region_id FROM expired_offices
        ),
        votes_per_candidate AS (
                SELECT
                        dt.office_type_id,
                        dt.region_id,
                        c.character_id,
                        COUNT(v.id) AS vote_count
                FROM distinct_types AS dt
                JOIN falukant_data.election AS e
                    ON e.office_type_id = dt.office_type_id
                JOIN falukant_data.vote AS v
                    ON v.election_id = e.id
                JOIN falukant_data.candidate AS c
                    ON c.election_id = e.id
                 AND c.id           = v.candidate_id
                WHERE e.date >= (NOW() - INTERVAL '30 days')
                GROUP BY dt.office_type_id, dt.region_id, c.character_id
        ),
        ranked_winners AS (
                SELECT
                        vpc.office_type_id,
                        vpc.region_id,
                        vpc.character_id,
                        ROW_NUMBER() OVER (
                                PARTITION BY vpc.office_type_id, vpc.region_id
                                ORDER BY vpc.vote_count DESC
                        ) AS rn
                FROM votes_per_candidate AS vpc
        ),
        selected_winners AS (
                SELECT
                        rw.office_type_id,
                        rw.region_id,
                        rw.character_id
                FROM ranked_winners AS rw
                JOIN falukant_type.political_office_type AS pot
                    ON pot.id = rw.office_type_id
                WHERE rw.rn <= pot.seats_per_region
        ),
        insert_winners AS (
                INSERT INTO falukant_data.political_office
                        (office_type_id, character_id, created_at, updated_at, region_id)
                SELECT
                        sw.office_type_id,
                        sw.character_id,
                        NOW(),
                        NOW(),
                        sw.region_id
                FROM selected_winners AS sw
                RETURNING id AS new_office_id, office_type_id, character_id, region_id
        ),
        count_inserted AS (
                SELECT
                        office_type_id,
                        region_id,
                        COUNT(*) AS inserted_count
                FROM insert_winners
                GROUP BY office_type_id, region_id
        ),
        needed_to_fill AS (
                SELECT
                        dt.office_type_id,
                        dt.region_id,
                        (pot.seats_per_region - COALESCE(ci.inserted_count, 0)) AS gaps
                FROM distinct_types AS dt
                JOIN falukant_type.political_office_type AS pot
                    ON pot.id = dt.office_type_id
                LEFT JOIN count_inserted AS ci
                    ON ci.office_type_id = dt.office_type_id
                 AND ci.region_id      = dt.region_id
                WHERE (pot.seats_per_region - COALESCE(ci.inserted_count, 0)) > 0
        ),
        random_candidates AS (
                SELECT
                        rtf.office_type_id,
                        rtf.region_id,
                        ch.id AS character_id,
                        ROW_NUMBER() OVER (
                                PARTITION BY rtf.office_type_id, rtf.region_id
                                ORDER BY RANDOM()
                        ) AS rn
                FROM needed_to_fill AS rtf
                JOIN falukant_data.character AS ch
                    ON ch.region_id = rtf.region_id
                 AND ch.user_id IS NULL
                 AND ch.birthdate <= NOW() - INTERVAL '21 days'
                 AND ch.title_of_nobility IN (
                             SELECT id FROM falukant_type.title WHERE label_tr != 'noncivil'
                     )
                 AND NOT EXISTS (
                             SELECT 1
                                 FROM falukant_data.political_office AS po2
                                 JOIN falukant_type.political_office_type AS pot2
                                     ON pot2.id = po2.office_type_id
                                WHERE po2.character_id = ch.id
                                    AND (po2.created_at + (pot2.term_length * INTERVAL '1 day')) >
                                                NOW() + INTERVAL '2 days'
                     )
        ),
        insert_random AS (
                INSERT INTO falukant_data.political_office
                        (office_type_id, character_id, created_at, updated_at, region_id)
                SELECT
                        rc.office_type_id,
                        rc.character_id,
                        NOW(),
                        NOW(),
                        rc.region_id
                FROM random_candidates AS rc
                JOIN needed_to_fill AS rtf
                    ON rtf.office_type_id = rc.office_type_id
                 AND rtf.region_id      = rc.region_id
                WHERE rc.rn <= rtf.gaps
                RETURNING id AS new_office_id, office_type_id, character_id, region_id
        )
        SELECT
                new_office_id AS office_id,
                office_type_id,
                character_id,
                region_id
            FROM insert_winners
        UNION ALL
        SELECT
                new_office_id AS office_id,
                office_type_id,
                character_id,
                region_id
            FROM insert_random;
"#;

pub const QUERY_USERS_IN_CITIES_OF_REGIONS: &str = r#"
        WITH RECURSIVE region_tree AS (
                SELECT id
                    FROM falukant_data.region
                 WHERE id = $1
                UNION ALL
                SELECT r2.id
                    FROM falukant_data.region AS r2
                    JOIN region_tree AS rt
                        ON r2.parent_id = rt.id
        )
        SELECT DISTINCT ch.user_id
            FROM falukant_data.character AS ch
            JOIN region_tree AS rt2
                ON ch.region_id = rt2.id
         WHERE ch.user_id IS NOT NULL;
"#;

pub const QUERY_NOTIFY_OFFICE_EXPIRATION: &str = r#"
        INSERT INTO falukant_log.notification
                (user_id, tr, created_at, updated_at)
        SELECT
                ch.user_id,
                'notify_office_expiring',
                NOW(),
                NOW()
            FROM falukant_data.political_office AS po
            JOIN falukant_type.political_office_type AS pot
                ON po.office_type_id = pot.id
            JOIN falukant_data.character AS ch
                ON ch.id = po.character_id
         WHERE ch.user_id IS NOT NULL
             AND (po.created_at + (pot.term_length * INTERVAL '1 day'))
                         BETWEEN (NOW() + INTERVAL '2 days')
                                 AND (NOW() + INTERVAL '2 days' + INTERVAL '1 second');
"#;

pub const QUERY_NOTIFY_ELECTION_CREATED: &str = r#"
    INSERT INTO falukant_log.notification
        (user_id, tr, created_at, updated_at)
    VALUES
        ($1, 'notify_election_created', NOW(), NOW());
"#;

pub const QUERY_NOTIFY_OFFICE_FILLED: &str = r#"
    INSERT INTO falukant_log.notification
        (user_id, tr, created_at, updated_at)
    VALUES
        ((SELECT user_id FROM falukant_data.character WHERE id = $1), 'notify_office_filled', NOW(), NOW());
"#;

pub const QUERY_GET_USERS_WITH_EXPIRING_OFFICES: &str = r#"
        SELECT DISTINCT ch.user_id
            FROM falukant_data.political_office AS po
            JOIN falukant_type.political_office_type AS pot
                ON po.office_type_id = pot.id
            JOIN falukant_data.character AS ch
                ON po.character_id = ch.id
         WHERE ch.user_id IS NOT NULL
             AND (po.created_at + (pot.term_length * INTERVAL '1 day'))
                     BETWEEN (NOW() + INTERVAL '2 days')
                             AND (NOW() + INTERVAL '2 days' + INTERVAL '1 second');
"#;

pub const QUERY_GET_USERS_IN_REGIONS_WITH_ELECTIONS: &str = r#"
        SELECT DISTINCT ch.user_id
            FROM falukant_data.election AS e
            JOIN falukant_data.character AS ch
                ON ch.region_id = e.region_id
         WHERE ch.user_id IS NOT NULL
             AND e.date >= NOW() - INTERVAL '1 day';
"#;

pub const QUERY_GET_USERS_WITH_FILLED_OFFICES: &str = r#"
        SELECT DISTINCT ch.user_id
            FROM falukant_data.political_office AS po
            JOIN falukant_data.character AS ch
                ON po.character_id = ch.id
         WHERE ch.user_id IS NOT NULL
             AND po.created_at >= NOW() - INTERVAL '1 minute';
"#;

pub const QUERY_PROCESS_ELECTIONS: &str = r#"
        SELECT office_id, office_type_id, character_id, region_id
            FROM falukant_data.process_elections();
"#;

pub const QUERY_TRIM_EXCESS_OFFICES_GLOBAL: &str = r#"
        WITH seats AS (
                SELECT
                        pot.id               AS office_type_id,
                        rt.id                AS region_id,
                        pot.seats_per_region AS seats_total
                FROM falukant_type.political_office_type AS pot
                JOIN falukant_type.region AS rt
                    ON pot.region_type = rt.label_tr
        ),
        ranked AS (
                SELECT
                        po.id,
                        po.office_type_id,
                        po.region_id,
                        s.seats_total,
                        ROW_NUMBER() OVER (
                                PARTITION BY po.office_type_id, po.region_id
                                ORDER BY po.created_at DESC
                        ) AS rn
                FROM falukant_data.political_office AS po
                JOIN seats AS s
                    ON s.office_type_id = po.office_type_id
                 AND s.region_id      = po.region_id
        ),
        to_delete AS (
                SELECT id
                    FROM ranked
                 WHERE rn > seats_total
        )
        DELETE FROM falukant_data.political_office
         WHERE id IN (SELECT id FROM to_delete);
"#;

pub const QUERY_UPDATE_CHARACTERS_HEALTH: &str = r#"
        UPDATE falukant_data."character"
             SET health = $1
         WHERE id = $2;
"#;

pub const QUERY_UPDATE_MOOD: &str = r#"
        UPDATE falukant_data."character" AS c
             SET mood_id = falukant_data.get_random_mood_id()
         WHERE c.health > 0
             AND random() < (1.0 / 50.0);
"#;

pub const QUERY_UPDATE_GET_ITEMS_TO_UPDATE: &str = r#"
        SELECT id, product_id, producer_id, quantity
            FROM falukant_log.production p
         WHERE p.production_timestamp::date < current_date;
"#;

pub const QUERY_UPDATE_GET_CHARACTER_IDS: &str = r#"
        SELECT fu.id AS user_id,
                     c.id  AS character_id,
                     c2.id AS director_id
            FROM falukant_data.falukant_user fu
            JOIN falukant_data.character c
                ON c.user_id = fu.id
 LEFT JOIN falukant_data.director d
                ON d.employer_user_id = fu.id
 LEFT JOIN falukant_data.character c2
                ON c2.id = d.director_character_id
         WHERE fu.id = $1;
"#;

pub const QUERY_UPDATE_KNOWLEDGE: &str = r#"
        UPDATE falukant_data.knowledge
             SET knowledge = LEAST(knowledge + $3, 100)
         WHERE character_id = $1
             AND product_id   = $2;
"#;

pub const QUERY_DELETE_LOG_ENTRY: &str = r#"
        DELETE FROM falukant_log.production
         WHERE id = $1;
"#;

pub const QUERY_GET_OPEN_CREDITS: &str = r#"
        SELECT
                c.id                 AS credit_id,
                c.amount,
                c.remaining_amount,
                c.interest_rate,
                fu.id                AS user_id,
                fu.money,
                c2.id                AS character_id,
                dp.created_at        AS debitor_prism_start,
                dp.created_at::date < current_date AS prism_started_previously
        FROM falukant_data.credit c
        JOIN falukant_data.falukant_user fu
            ON fu.id = c.falukant_user_id
        JOIN falukant_data.character c2
            ON c2.user_id = c.falukant_user_id
        LEFT JOIN falukant_data.debtors_prism dp
            ON dp.character_id = c2.id
     WHERE c.remaining_amount > 0
         AND c.updated_at::date < current_date;
"#;

pub const QUERY_UPDATE_CREDIT: &str = r#"
        UPDATE falukant_data.credit c
             SET remaining_amount = $1
         WHERE falukant_user_id = $2;
"#;

pub const QUERY_CLEANUP_CREDITS: &str = r#"
    DELETE FROM falukant_data.credit
     WHERE remaining_amount <= 0.01;
"#;

pub const QUERY_ADD_CHARACTER_TO_DEBTORS_PRISM: &str = r#"
        INSERT INTO falukant_data.debtors_prism (character_id)
        VALUES ($1);
"#;

pub const QUERY_RANDOM_HEIR: &str = r#"
        WITH chosen AS (
                SELECT
                    cr.id               AS relation_id,
                    cr.child_character_id
                FROM
                    falukant_data.child_relation AS cr
                JOIN
                    falukant_data.character      AS ch
                    ON ch.id = cr.child_character_id
                WHERE
                    (cr.father_character_id = $1 OR cr.mother_character_id = $1)
                    AND ch.region_id = (
                            SELECT region_id
                                FROM falukant_data.character
                             WHERE id = $1
                    )
                    AND ch.birthdate >= NOW() - INTERVAL '10 days'
                    AND ch.title_of_nobility = (
                            SELECT id
                                FROM falukant_type.title
                             WHERE label_tr = 'noncivil'
                    )
                ORDER BY RANDOM()
                LIMIT 1
        )
        UPDATE
            falukant_data.child_relation AS cr2
        SET
            is_heir    = TRUE,
            updated_at = NOW()
        FROM
            chosen
        WHERE
            cr2.id = chosen.relation_id
        RETURNING
            chosen.child_character_id;
"#;

pub const QUERY_UPDATE_USER_MONEY: &str = r#"
    UPDATE falukant_data.falukant_user
         SET money     = $1,
             updated_at = NOW()
     WHERE id = $2;
"#;

pub const QUERY_GET_FALUKANT_USER_ID: &str = r#"
        SELECT user_id
            FROM falukant_data.character
         WHERE id = $1
         LIMIT 1;
"#;

pub const QUERY_AUTOBATISM: &str = r#"
        UPDATE falukant_data.child_relation
             SET name_set = TRUE
         WHERE id IN (
                 SELECT cr.id
                     FROM falukant_data.child_relation cr
                     JOIN falukant_data.character c
                         ON c.id = cr.child_character_id
                    WHERE cr.name_set = FALSE
                        AND c.birthdate < current_date - INTERVAL '5 days'
         );
"#;

pub const QUERY_GET_PREGNANCY_CANDIDATES: &str = r#"
        SELECT
            r.character1_id AS father_cid,
            r.character2_id AS mother_cid,
            c1.title_of_nobility,
            c1.last_name,
            c1.region_id,
            fu1.id AS father_uid,
            fu2.id AS mother_uid,
            ((CURRENT_DATE - c1.birthdate::date)
             + (CURRENT_DATE - c2.birthdate::date)) / 2 AS avg_age_days,
            100.0 /
                (1 + EXP(
                         0.0647 * (
                             ((CURRENT_DATE - c1.birthdate::date)
                                + (CURRENT_DATE - c2.birthdate::date)) / 2
                         ) - 0.0591
                     )) AS prob_pct
        FROM falukant_data.relationship r
        JOIN falukant_type.relationship r2
            ON r2.id = r.relationship_type_id
         AND r2.tr = 'married'
        JOIN falukant_data.character c1
            ON c1.id = r.character1_id
        JOIN falukant_data.character c2
            ON c2.id = r.character2_id
        LEFT JOIN falukant_data.falukant_user fu1
            ON fu1.id = c1.user_id
        LEFT JOIN falukant_data.falukant_user fu2
            ON fu2.id = c2.user_id
     WHERE random() * 100 < (
            100.0 /
                (1 + EXP(
                         0.11166347 * (
                             ((CURRENT_DATE - c1.birthdate::date)
                                + (CURRENT_DATE - c2.birthdate::date)) / 2
                         ) - 2.638267
                     ))
     ) / 2;
"#;

pub const QUERY_INSERT_CHILD: &str = r#"
        INSERT INTO falukant_data.character (
            user_id,
            region_id,
            first_name,
            last_name,
            birthdate,
            gender,
            title_of_nobility,
            mood_id,
            created_at,
            updated_at
        ) VALUES (
            NULL,
            $1::int,
            (
                SELECT id
                    FROM falukant_predefine.firstname
                 WHERE gender = $2
                 ORDER BY RANDOM()
                 LIMIT 1
            ),
            $3::int,
            NOW(),
            $2::varchar,
            $4::int,
            (
                SELECT id
                    FROM falukant_type.mood
                 ORDER BY RANDOM()
                 LIMIT 1
            ),
            NOW(),
            NOW()
        )
        RETURNING id AS child_cid;
"#;

pub const QUERY_INSERT_CHILD_RELATION: &str = r#"
        INSERT INTO falukant_data.child_relation (
            father_character_id,
            mother_character_id,
            child_character_id,
            name_set,
            created_at,
            updated_at
        )
        VALUES (
            $1::int,
            $2::int,
            $3::int,
            FALSE,
            NOW(), NOW()
        );
"#;

pub const QUERY_DELETE_KNOWLEDGE: &str = r#"
        DELETE FROM falukant_data.knowledge
         WHERE character_id = $1;
"#;

pub const QUERY_DELETE_DEBTORS_PRISM: &str = r#"
        DELETE FROM falukant_data.debtors_prism
         WHERE character_id = $1;
"#;

pub const QUERY_DELETE_POLITICAL_OFFICE: &str = r#"
        WITH removed AS (
                DELETE FROM falukant_data.political_office
                 WHERE character_id = $1
                RETURNING office_type_id, region_id
        ),
        affected AS (
                SELECT DISTINCT office_type_id, region_id
                    FROM removed
        ),
        seats AS (
                SELECT
                        pot.id               AS office_type_id,
                        rt.id                AS region_id,
                        pot.seats_per_region AS seats_total
                FROM falukant_type.political_office_type AS pot
                JOIN falukant_type.region AS rt
                    ON pot.region_type = rt.label_tr
                JOIN affected AS a
                    ON a.office_type_id = pot.id
                 AND a.region_id      = rt.id
        ),
        ranked AS (
                SELECT
                        po.id,
                        po.office_type_id,
                        po.region_id,
                        s.seats_total,
                        ROW_NUMBER() OVER (
                                PARTITION BY po.office_type_id, po.region_id
                                ORDER BY po.created_at DESC
                        ) AS rn
                FROM falukant_data.political_office AS po
                JOIN seats AS s
                    ON s.office_type_id = po.office_type_id
                 AND s.region_id      = po.region_id
        ),
        to_delete AS (
                SELECT id
                    FROM ranked
                 WHERE rn > seats_total
        )
        DELETE FROM falukant_data.political_office
         WHERE id IN (SELECT id FROM to_delete);
"#;

pub const QUERY_DELETE_ELECTION_CANDIDATE: &str = r#"
        DELETE FROM falukant_data.election_candidate
         WHERE character_id = $1;
"#;

pub const QUERY_GET_STOCK_TYPE_ID: &str = r#"
SELECT id FROM falukant_type.stock WHERE label_tr = $1 LIMIT 1;
"#;

pub const QUERY_GET_INVENTORY_ITEMS: &str = r#"
SELECT i.id AS inventory_id, i.quantity AS inventory_quantity, i.stock_id FROM falukant_data.inventory i JOIN falukant_data.stock s ON i.stock_id = s.id JOIN falukant_data.branch b ON s.branch_id = b.id WHERE b.region_id = $1 AND s.stock_type_id = $2;
"#;

pub const QUERY_REDUCE_INVENTORY: &str = r#"
UPDATE falukant_data.inventory SET quantity = $1 WHERE id = $2;
"#;

pub const QUERY_DELETE_INVENTORY: &str = r#"
DELETE FROM falukant_data.inventory WHERE stock_id = $1;
"#;

pub const QUERY_DELETE_STOCK: &str = r#"
DELETE FROM falukant_data.stock WHERE id = $1;
"#;

pub const QUERY_GET_STOCK_INVENTORY: &str = r#"
SELECT id, quantity FROM falukant_data.inventory WHERE stock_id = $1;
"#;

pub const QUERY_CAP_INVENTORY: &str = r#"
UPDATE falukant_data.inventory SET quantity = $1 WHERE id = $2;
"#;

pub const QUERY_GET_USER_INVENTORY_ITEMS: &str = r#"
SELECT i.id AS inventory_id, i.quantity AS inventory_quantity, i.stock_id
FROM falukant_data.inventory i
JOIN falukant_data.stock s ON i.stock_id = s.id
JOIN falukant_data.branch b ON s.branch_id = b.id
WHERE b.falukant_user_id = $1 AND s.stock_type_id = $2;
"#;
// Produce worker queries
pub const QUERY_GET_FINISHED_PRODUCTIONS: &str = r#"
    SELECT
                p.id              AS production_id,
                p.branch_id,
                p.product_id,
                p.quantity,
                p.start_timestamp,
                pr.production_time,
                br.region_id,
        br.falukant_user_id AS user_id,
    ROUND(
            GREATEST(
                0,
                LEAST(
                    100,
                    (
            (COALESCE(k.knowledge, 0) * 0.75
             + COALESCE(k2.knowledge, 0) * 0.25)
            * COALESCE(pwe.quality_effect, 100) / 100.0
                    )
                )
            )
        )::int AS quality
        FROM falukant_data.production p
        JOIN falukant_type.product pr
            ON p.product_id = pr.id
        JOIN falukant_data.branch br
            ON p.branch_id = br.id
        JOIN falukant_data.character c
            ON c.user_id = br.falukant_user_id
        LEFT JOIN falukant_data.knowledge k
            ON p.product_id = k.product_id
         AND k.character_id = c.id
        LEFT JOIN falukant_data.director d
            ON d.employer_user_id = c.user_id
        LEFT JOIN falukant_data.knowledge k2
            ON k2.character_id = d.director_character_id
         AND k2.product_id   = p.product_id
        LEFT JOIN falukant_data.weather w
            ON w.region_id = br.region_id
        LEFT JOIN falukant_type.product_weather_effect pwe
            ON pwe.product_id = p.product_id
           AND pwe.weather_type_id = w.weather_type_id
    -- Wetter-Effekte derzeit aus der Qualitätsberechnung entfernt
        WHERE p.start_timestamp + INTERVAL '1 minute' * pr.production_time <= NOW()
        ORDER BY p.start_timestamp;
"#;

pub const QUERY_DELETE_PRODUCTION: &str = r#"
    DELETE FROM falukant_data.production
    WHERE id = $1;
"#;

pub const QUERY_INSERT_UPDATE_PRODUCTION_LOG: &str = r#"
    INSERT INTO falukant_log.production (
        region_id,
        product_id,
        quantity,
        producer_id,
        production_date
    ) VALUES ($1, $2, $3, $4, CURRENT_DATE)
    ON CONFLICT (producer_id, product_id, region_id, production_date)
    DO UPDATE
    SET quantity = falukant_log.production.quantity + EXCLUDED.quantity;
"#;

pub const QUERY_ADD_OVERPRODUCTION_NOTIFICATION: &str = r#"
    INSERT INTO falukant_log.notification (
        user_id,
        tr,
        shown,
        created_at,
        updated_at
    ) VALUES ($1, $2, FALSE, NOW(), NOW());
"#;

// Aliases for personal variants (keeps original prepared statement names used in events.worker)
pub const QUERY_REDUCE_INVENTORY_PERSONAL: &str = QUERY_REDUCE_INVENTORY;
pub const QUERY_DELETE_INVENTORY_PERSONAL: &str = QUERY_DELETE_INVENTORY;
pub const QUERY_DELETE_STOCK_PERSONAL: &str = QUERY_DELETE_STOCK;
pub const QUERY_GET_STOCK_INVENTORY_PERSONAL: &str = QUERY_GET_STOCK_INVENTORY;
pub const QUERY_CAP_INVENTORY_PERSONAL: &str = QUERY_CAP_INVENTORY;

// value_recalculation worker queries
pub const QUERY_UPDATE_PRODUCT_KNOWLEDGE_USER: &str = r#"
    UPDATE falukant_data.knowledge k
       SET knowledge = LEAST(100, k.knowledge + 1)
      FROM falukant_data.character c
      JOIN falukant_log.production p
        ON DATE(p.production_timestamp) = CURRENT_DATE - INTERVAL '1 day'
     WHERE c.id = k.character_id
       AND c.user_id = 18
       AND k.product_id = 10;
"#;

pub const QUERY_DELETE_OLD_PRODUCTIONS: &str = r#"
    DELETE FROM falukant_log.production flp
     WHERE DATE(flp.production_timestamp) < CURRENT_DATE;
"#;

pub const QUERY_GET_PRODUCERS_LAST_DAY: &str = r#"
    SELECT p.producer_id
      FROM falukant_log.production p
     WHERE DATE(p.production_timestamp) = CURRENT_DATE - INTERVAL '1 day'
     GROUP BY producer_id;
"#;

pub const QUERY_UPDATE_REGION_SELL_PRICE: &str = r#"
    UPDATE falukant_data.town_product_worth tpw
       SET worth_percent =
           GREATEST(
               0,
               LEAST(
                   CASE
                       WHEN s.quantity > COALESCE(s.avg_sells, 0) * 1.05 THEN tpw.worth_percent + 1
                       WHEN s.quantity < COALESCE(s.avg_sells, 0) * 0.95 THEN tpw.worth_percent - 1
                       ELSE tpw.worth_percent
                   END,
                   100
               )
           )
      FROM (
          SELECT region_id,
                 product_id,
                 quantity,
                 (SELECT AVG(quantity)
                    FROM falukant_log.sell avs
                   WHERE avs.product_id = s.product_id) AS avg_sells
            FROM falukant_log.sell s
           WHERE DATE(s.sell_timestamp) = CURRENT_DATE - INTERVAL '1 day'
      ) s
     WHERE tpw.region_id = s.region_id
       AND tpw.product_id = s.product_id;
"#;

pub const QUERY_DELETE_REGION_SELL_PRICE: &str = r#"
    DELETE FROM falukant_log.sell s
     WHERE DATE(s.sell_timestamp) < CURRENT_DATE;
"#;

pub const QUERY_GET_SELL_REGIONS: &str = r#"
    SELECT s.region_id
      FROM falukant_log.sell s
     WHERE DATE(s.sell_timestamp) = CURRENT_DATE - INTERVAL '1 day'
     GROUP BY region_id;
"#;

pub const QUERY_HOURLY_PRICE_RECALCULATION: &str = r#"
    WITH city_sales AS (
        SELECT s.region_id, s.product_id, SUM(s.quantity) AS total_sold
        FROM falukant_log.sell s
        WHERE s.sell_timestamp >= NOW() - INTERVAL '1 hour'
        GROUP BY s.region_id, s.product_id
    ),
    world_avg AS (
        SELECT product_id, AVG(total_sold) AS avg_sold
        FROM city_sales
        GROUP BY product_id
    ),
    adjustments AS (
        SELECT
            cs.region_id,
            cs.product_id,
            CASE
                WHEN cs.total_sold > COALESCE(wa.avg_sold, 0) * 1.05 THEN 1.10
                WHEN cs.total_sold < COALESCE(wa.avg_sold, 0) * 0.95 THEN 0.90
                ELSE 1.00
            END AS factor
        FROM city_sales cs
        JOIN world_avg wa ON wa.product_id = cs.product_id
    )
    UPDATE falukant_data.town_product_worth tpw
       SET worth_percent = GREATEST(0, LEAST(100, tpw.worth_percent * adj.factor))
      FROM adjustments adj
     WHERE tpw.region_id = adj.region_id
       AND tpw.product_id = adj.product_id;
"#;

pub const QUERY_SET_MARRIAGES_BY_PARTY: &str = r#"
    WITH updated_relations AS (
        UPDATE falukant_data.relationship AS rel
           SET relationship_type_id = (
               SELECT id
                 FROM falukant_type.relationship AS rt
                WHERE rt.tr = 'married'
           )
         WHERE rel.id IN (
               SELECT rel2.id
                 FROM falukant_data.party AS p
                 JOIN falukant_type.party AS pt
                   ON pt.id = p.party_type_id
                  AND pt.tr = 'wedding'
                 JOIN falukant_data.falukant_user AS fu
                   ON fu.id = p.falukant_user_id
                 JOIN falukant_data.character AS c
                   ON c.user_id = fu.id
                 JOIN falukant_data.relationship AS rel2
                   ON rel2.character1_id = c.id
                   OR rel2.character2_id = c.id
                 JOIN falukant_type.relationship AS rt2
                   ON rt2.id = rel2.relationship_type_id
                  AND rt2.tr = 'engaged'
                WHERE p.created_at <= NOW() - INTERVAL '1 day'
           )
        RETURNING character1_id, character2_id
    )
    SELECT
        c1.user_id AS character1_user,
        c2.user_id AS character2_user
      FROM updated_relations AS ur
      JOIN falukant_data.character AS c1
        ON c1.id = ur.character1_id
      JOIN falukant_data.character AS c2
        ON c2.id = ur.character2_id;
"#;

pub const QUERY_GET_STUDYINGS_TO_EXECUTE: &str = r#"
    SELECT
        l.id,
        l.associated_falukant_user_id,
        l.associated_learning_character_id,
        l.learn_all_products,
        l.learning_recipient_id,
        l.product_id,
        lr.tr
      FROM falukant_data.learning l
      JOIN falukant_type.learn_recipient lr
        ON lr.id = l.learning_recipient_id
     WHERE l.learning_is_executed = FALSE
       AND l.created_at + INTERVAL '1 day' < NOW();
"#;

pub const QUERY_GET_OWN_CHARACTER_ID: &str = r#"
    SELECT id
      FROM falukant_data.character c
     WHERE c.user_id = $1;
"#;

pub const QUERY_INCREASE_ONE_PRODUCT_KNOWLEDGE: &str = r#"
    UPDATE falukant_data.knowledge k
       SET knowledge = LEAST(100, k.knowledge + $1)
     WHERE k.character_id = $2
       AND k.product_id   = $3;
"#;

pub const QUERY_INCREASE_ALL_PRODUCTS_KNOWLEDGE: &str = r#"
    UPDATE falukant_data.knowledge k
       SET knowledge = LEAST(100, k.knowledge + $1)
     WHERE k.character_id = $2;
"#;

pub const QUERY_SET_LEARNING_DONE: &str = r#"
    UPDATE falukant_data.learning
       SET learning_is_executed = TRUE,
           updated_at = NOW()
     WHERE id = $1;
"#;