import { Injectable } from '@nestjs/common';
import { InjectDataSource } from '@nestjs/typeorm';
import { DataSource } from 'typeorm';

@Injectable()
export class GeneralService {
    constructor(
        @InjectDataSource('emsConnection')
        private dataSource: DataSource
    ) { }

    async getRegions(): Promise<any[]> {
        const generalDatabase = 'nGeneral'

        const result = await this.dataSource.query(`
            SELECT * FROM ${generalDatabase}..vRegions;
            `)
        return result
    }

    async getDistricts(region_id: number): Promise<any[]> {
        const generalDatabase = 'nGeneral'

        const result = await this.dataSource.query(`
            SELECT c.*, d.name AS district_name
            FROM ${generalDatabase}..vCities c
            JOIN ${generalDatabase}..vDistricts d ON d.id_region = c.id_region AND d.id = c.id_district
            WHERE c.id_region = ${region_id};
            `)
        return result
    }

    async getCities(offset?: number, limit?: number, search?: string, id?: number): Promise<any[]> {
        const generalDatabase = 'nGeneral'

        const result = await this.dataSource.query(`
            SELECT * FROM ${generalDatabase}..Cities
            ${id ? `WHERE id = ${id}` : ''}
            ${search ? `WHERE name LIKE '%${search || ''}%'` : ''}
            ORDER BY id 
            OFFSET ${Number(offset) || 0} ROWS 
            FETCH NEXT ${Number(limit) || 10} ROWS ONLY;
            `)
        return result
    }

    async getTypes(): Promise<any[]> {
        const generalDatabase = 'nGeneral'

        const result = await this.dataSource.query(`
            SELECT * FROM ${generalDatabase}..tTypes
            ORDER BY id
            `)
        return result
    }

    async getObjects(offset?: number, limit?: number, city_id?: number): Promise<any[]> {
        const generalDatabase = 'nGeneral'

        const result = await this.dataSource.query(`
            SELECT * FROM ${generalDatabase}..vObjects
            ${city_id ? `WHERE id_city = ${Number(city_id)}` : ''}
            ORDER BY id_object
            OFFSET ${Number(offset) || 0} ROWS
            FETCH NEXT ${Number(limit) || 10} ROWS ONLY;
            `)
        return result
    }

    // TODO: GisDB
    async getObjectsList(city_id: number, year: number, planning: number, type?: number): Promise<any[]> {
        const generalDatabase = 'nGeneral'
        const gisDatabase = 'New_Gis'

        const result = await this.dataSource.query(type ? `
                WITH cte_split(type_id, split_value, caption_params) AS
                (
                -- anchor member
                SELECT DISTINCT
                    type_id,
                    CAST(LEFT(caption_params, CHARINDEX(',', caption_params + ',') - 1) AS VARCHAR(255)),  -- Explicitly casting to VARCHAR
                    STUFF(caption_params, 1, CHARINDEX(',', caption_params + ','), '')
                FROM ${gisDatabase}..caption_params
                WHERE city_id = -1 AND user_id = -1
                
                UNION ALL
                
                -- recursive member
                SELECT
                    type_id,
                    CAST(LEFT(caption_params, CHARINDEX(',', caption_params + ',') - 1) AS VARCHAR(255)),  -- Explicitly casting to VARCHAR
                    STUFF(caption_params, 1, CHARINDEX(',', caption_params + ','), '')
                FROM cte_split
                WHERE caption_params > ''
                )
                SELECT
                    o.object_id,
                o.type,
                o.id_city,
                o.year,
                o.planning,
                string_agg(cast(v.value as varchar), ',') as caption
                FROM ${generalDatabase}..vObjects o
                JOIN cte_split c ON o.type = c.type_id
                JOIN ${generalDatabase}..tParameters p ON p.id = split_value
                LEFT JOIN ${generalDatabase}..tValues v
                ON 
                    v.id_param = split_value 
                    AND v.id_object = o.object_id 
                    AND (v.date_po IS NULL)
                AND (v.date_s < DATEFROMPARTS(${Number(year) + 1},01,01))

                WHERE
                    o.id_city = ${city_id}
                    AND o.year = ${year}
                    AND o.type = ${type}
                    AND
                    (
                    CASE
                        WHEN TRY_CAST(o.planning AS BIT) IS NOT NULL THEN TRY_CAST(o.planning AS BIT)
                        WHEN o.planning = 'TRUE' THEN 1
                        WHEN o.planning = 'FALSE' THEN 0
                        ELSE NULL
                    END
                    ) = ${planning}
                GROUP BY object_id, type, id_city, year, planning;
                `:
            `
                SELECT 
                    ${generalDatabase}..tTypes.id AS id,
                    ${generalDatabase}..tTypes.name AS name,
                    COUNT(vo.type) AS count,
                    tr.r,
                    tr.g,
                    tr.b
                FROM 
                    ${generalDatabase}..vObjects vo
                JOIN
                    ${generalDatabase}..tTypes ON vo.type = ${generalDatabase}..tTypes.id
                LEFT JOIN ${gisDatabase}..TypeRoles tr ON tr.id = ${generalDatabase}..tTypes.id
                WHERE 
                    vo.id_city = ${city_id} AND vo.year = ${year}
                    AND
                    (
                    CASE 
                        WHEN TRY_CAST(vo.planning AS BIT) IS NOT NULL THEN TRY_CAST(vo.planning AS BIT)
                        WHEN vo.planning = 'TRUE' THEN 1
                        WHEN vo.planning = 'FALSE' THEN 0
                        ELSE NULL
                    END
                    ) = ${planning}
                GROUP BY 
                    ${generalDatabase}..tTypes.id,
                    ${generalDatabase}..tTypes.name,
                    tr.r,
                    tr.g,
                    tr.b;
                `
        )
        return result
    }

    async getObjectById(id: string): Promise<any[]> {
        const generalDatabase = 'nGeneral'
        const gisDatabase = 'New_Gis'

        const result = await this.dataSource.query(`
            SELECT * FROM ${generalDatabase}..vObjects
            WHERE id_object = '${id}'
            `)
        return result
    }

    async getValuesByObjectId(object_id: string): Promise<any[]> {
        const generalDatabase = 'nGeneral'

        const result = await this.dataSource.query(`
            SELECT id_object, id_param, CAST(v.value AS varchar(max)) AS value,
                date_s,
                date_po,
                id_user
            FROM ${generalDatabase}..tValues v
            JOIN ${generalDatabase}..tParameters p ON v.id_param = p.id
            WHERE id_object = '${object_id}'
            `)
        return result
    }

    async getParamsById(param_id: number): Promise<any[]> {
        const generalDatabase = 'nGeneral'

        const result = await this.dataSource.query(`
            SELECT * FROM ${generalDatabase}..TParameters
            WHERE id = '${param_id}'
            `)
        return result
    }

    tcbParamQuery = (vtable: string, id_city: number) => {
        const generalDatabase = 'nGeneral'

        switch (vtable) {
            case 'vStreets':
                return `SELECT * FROM ${generalDatabase}..${vtable} WHERE id_city = ${id_city};`
            case 'vBoilers':
                return `SELECT * FROM ${generalDatabase}..${vtable} WHERE id_city = ${id_city};`
            default:
                return `SELECT * FROM ${generalDatabase}..${vtable};`
        }
    }

    async getTCBParams(vtable: string, id_city: number, id?: number): Promise<any[]> {
        const generalDatabase = 'nGeneral'
        const query = id ? `
            SELECT * FROM ${generalDatabase}..${vtable} WHERE id = '${id}'
        ` : this.tcbParamQuery(vtable, id_city)

        const result = await this.dataSource.query(query)
        return result
    }

    async getSearchObjects(q: string, id_city: number, year: number) {
        const generalDatabase = 'nGeneral'
        const gisDatabase = 'New_Gis'

        const result = await this.dataSource.query(`
                WITH RankedValues AS (
                    SELECT
                        id_object,
                        date_s,
                        CAST(value AS varchar(max)) AS value,
                        ROW_NUMBER() OVER (PARTITION BY id_object ORDER BY date_s DESC) AS rn,
                        o.id_city AS id_city,
                        o.year AS year
                    FROM ${generalDatabase}..tValues
                    JOIN ${generalDatabase}..tObjects o ON o.id = id_object
                    WHERE CAST(value AS varchar(max)) LIKE '%${q}%'
                    )
                SELECT
                    id_object,
                    date_s,
                    value,
                    id_city,
                    year
                FROM RankedValues
                WHERE rn = 1 AND id_city = ${id_city} AND year = ${year};
                `)
        return result
    }
}