-- функция для создания скелета дороги
CREATE OR REPLACE FUNCTION road_processing.generate_road_skeleton(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT,
    p_tolerance FLOAT default 2.0
)
RETURNS VOID AS $$
begin
-- удаляем старые записи из таблицы road_skeleton
	delete from road_processing.road_skeleton
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;
	
	with
…

	-- Создаем сплошной полигон без дырок
	filled_buffered_united_road AS (
	    SELECT ST_MakePolygon(ST_ExteriorRing(geometry)) as geometry
	    FROM buffered_united_road
	),

	-- Упрощение геометрии для построения скелета
	simplified_filled_buffered_united_road AS (
	    SELECT ST_SimplifyPreserveTopology(geometry, p_tolerance) as geometry
	    FROM filled_buffered_united_road
	),

	-- Строим скелет
	skeleton AS (
	SELECT COALESCE(ST_StraightSkeleton(geometry),
	 ST_ApproximateMedialAxis(geometry)) as geometry
--	SELECT ST_ApproximateMedialAxis(geometry) as geometry
--	    SELECT ST_StraightSkeleton(geometry) as geometry
-- SELECT CG_StraightSkeletonPartition(geometry, true) as geometry
	    FROM simplified_filled_buffered_united_road
	)

	-- добавляем скелет в таблицу
	insert into road_processing.road_skeleton (part_id, layer_id, object_id, geom)
	select 
		p_part_id,
		p_layer_id,
		p_object_id,
		geometry
	from skeleton;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fill_road_segments(
    p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT
)
RETURNS VOID AS $$
BEGIN
	-- удаляем старые записи из таблицы road_segments
	delete from road_processing.road_segments
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;	

    INSERT INTO road_processing.road_segments (part_id, layer_id, object_id, id, geom, length)
-- получаем линии
    WITH dumped AS (
        SELECT (ST_Dump(geom)).geom AS geom
        FROM road_processing.road_skeleton
        WHERE part_id = p_part_id AND  layer_id = p_layer_id AND object_id = p_object_id 
    ),
-- создаём коллекцию (список) из линий
    collected AS (
        SELECT ST_Collect(geom) AS geom
        FROM dumped
    ),
-- разделяем линии по точкам пересечения,
    noded AS (
        SELECT ST_Node(geom) AS geom
        FROM collected
    ),
    geometries AS (
        SELECT 
            p_part_id as part_id, 
            p_layer_id as layer_id, 
            p_object_id as object_id, 
            (ST_Dump(geom)).geom AS geom
        FROM noded
    )
    SELECT 
        part_id, 
        layer_id, 
        object_id,
        row_number() OVER () as id,
        geom,
        ST_Length(geom) as length
    FROM geometries;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fill_road_vertices(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT
)
RETURNS VOID AS $$
begin
-- удаляем старые записи из таблицы road_vertices
	delete from road_processing.road_vertices
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;	

	INSERT INTO road_processing.road_vertices (part_id, layer_id, object_id, id, in_edges, out_edges, x, y, geom)
	SELECT 
   		p_part_id,
		p_layer_id,
		p_object_id,
    	id,
    	in_edges,
    	out_edges,
    	x,
    	y,
    	geom
	FROM pgr_extractVertices(format('SELECT id, geom FROM road_processing.road_segments WHERE part_id = %s AND layer_id = %s AND object_id = %L',
							 p_part_id, p_layer_id, p_object_id));
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.update_road_segments(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT
)
RETURNS VOID AS $$
begin
UPDATE road_processing.road_segments AS r
-- находим точку начала сегмента
	SET source = (
	    SELECT v.id FROM road_processing.road_vertices v
	    WHERE part_id = p_part_id AND  layer_id = p_layer_id AND object_id = p_object_id 
			 AND ST_DWithin(ST_StartPoint(r.geom), v.geom, 1)
	    LIMIT 1
	),
-- находим точку конца сегмента

	target = (
	    SELECT v.id FROM road_processing.road_vertices v
	    WHERE part_id = p_part_id AND  layer_id = p_layer_id AND object_id = p_object_id 
			AND ST_DWithin(ST_EndPoint(r.geom), v.geom, 1)
	    LIMIT 1
	);
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fill_leaf_nodes(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT
)
RETURNS VOID AS $$
begin
-- удаляем старые записи из таблицы fill_leaf_nodes
	delete from road_processing.leaf_nodes
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;	

insert into road_processing.leaf_nodes(part_id, layer_id, object_id, vertex_id)
	SELECT p_part_id as part_id, p_layer_id as layer_id, p_object_id as object_id, vertex_id
	FROM (
	    SELECT source AS vertex_id FROM road_processing.road_segments
		WHERE part_id = p_part_id AND  layer_id = p_layer_id AND object_id = p_object_id 
	    UNION ALL
	    SELECT target FROM road_processing.road_segments
		WHERE part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id 
	) AS all_vertices
	GROUP BY vertex_id
	HAVING COUNT(*) = 1;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fill_leaf_cost_matrix(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT
)
RETURNS VOID AS $$
begin
-- удаляем старые записи из таблицы leaf_cost_matrix
	delete from road_processing.leaf_cost_matrix
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;	

	insert into road_processing.leaf_cost_matrix(part_id, layer_id, object_id, start_vid, end_vid, agg_cost)
		select p_part_id as part_id, p_layer_id as layer_id, p_object_id as object_id, start_vid, end_vid, agg_cost
		FROM pgr_dijkstraCostMatrix(
	    	format('SELECT id, source, target, length AS cost FROM road_processing.road_segments WHERE part_id = %s AND layer_id = %s AND object_id = %L',
	    		p_part_id, p_layer_id, p_object_id),
	    		(
	    			select
	    			array_agg(vertex_id) FROM road_processing.leaf_nodes
	     			WHERE part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id
	    		),
	    	directed := false);
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fill_diameter_info(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT
)
RETURNS VOID AS $$
begin
-- удаляем старые записи из таблицы diameter_info
	delete from road_processing.diameter_info
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;	

	insert into road_processing.diameter_info(part_id, layer_id, object_id, start_vid, end_vid, max_distance)
	SELECT
	    p_part_id as part_id, p_layer_id as layer_id, p_object_id as object_id, start_vid, end_vid, agg_cost AS max_distance
	FROM road_processing.leaf_cost_matrix
	WHERE part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id
	ORDER BY agg_cost DESC
	LIMIT 1;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fill_road_zones(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT,
    road_segment_len DOUBLE precision default 300, -- длинна сегмента дороги
    road_segment_wide DOUBLE precision default 50 -- ширина сегмента дороги
)
RETURNS VOID AS $$
begin
	-- удаляем старые записи из таблицы road_zones
	delete from road_processing.road_zones
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;

WITH 
dumped_lines AS (
  SELECT 
    (ST_Dump(geom)).geom AS line_geom,
    (ST_Dump(geom)).path[1] as part_order
  FROM road_processing.final_longest_route
  WHERE part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id
),
-- Собираем все точки в правильном порядке
ordered_points AS (
  SELECT 
    ST_StartPoint(line_geom) as point,
    part_order,
    1 as point_type  -- start point
  FROM dumped_lines
  UNION ALL
  SELECT 
    ST_EndPoint(line_geom) as point,
    part_order,
    2 as point_type  -- end point
  FROM dumped_lines
),
-- Убираем дубликаты (точки соединения)
unique_points AS (
  SELECT DISTINCT ON (point) 
    point,
    part_order,
    point_type
  FROM ordered_points
  ORDER BY point, part_order, point_type
),
-- получеам Linestring из Multilinestring
centerline as (
-- Создаем линию из точек
SELECT 
  ST_MakeLine(point ORDER BY part_order, point_type) as linestring_geom,
  ST_Length(ST_MakeLine(point ORDER BY part_order, point_type)) as total_length
FROM unique_points),
-- Разбиваем на сегменты по 300 метров
final_segments as (
	SELECT 
	  generate_series(0, floor(total_length / road_segment_len)::int) as seg_num,
	  ST_LineSubstring(
	    linestring_geom,
	    generate_series(0, floor(total_length / road_segment_len)::int) * road_segment_len / total_length,
	    LEAST((generate_series(0, floor(total_length / road_segment_len)::int) + 1) * road_segment_len / total_length, 1.0)
	  ) as segment_geom,
	  ST_Length(
	    ST_LineSubstring(
	      linestring_geom,
	      generate_series(0, floor(total_length / road_segment_len)::int) * road_segment_len / total_length,
	      LEAST((generate_series(0, floor(total_length / road_segment_len)::int) + 1) * road_segment_len / total_length, 1.0)
	    )
	  ) as segment_length
	FROM centerline)
	insert into road_processing.road_zones(part_id, layer_id, object_id, zone_id, geom)
	select 
		p_part_id as part_id, p_layer_id as layer_id, p_object_id as object_id,
		row_number() over() as zone_id,
		ST_Buffer(segment_geom, road_segment_wide, 'endcap=flat join=mitre') as geom
	from final_segments;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.merge_overlapping_zones(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT,
    tolerance_percent DOUBLE PRECISION DEFAULT 50 -- процентный порог пересечения зон. Чем меньше, тем больше по площади могут получиться зоны.
)
RETURNS VOID AS $$
DECLARE
    merged INTEGER;
    v_id1 INTEGER;
    v_id2 INTEGER;
    v_union_geom GEOMETRY(GEOMETRY, 3857);
BEGIN
    LOOP
        -- Находим пару для объединения
        SELECT 
            a.zone_id, 
            b.zone_id,
            ST_Union(a.geom, b.geom)
        INTO 
            v_id1, 
            v_id2,
            v_union_geom
        FROM road_processing.road_zones a
        JOIN road_processing.road_zones b ON a.zone_id < b.zone_id
        WHERE road_processing.safe_st_intersects(a.geom, b.geom)
            AND ST_Area(road_processing.safe_st_intersection(a.geom, b.geom)) > 
                (tolerance_percent / 100.0) * LEAST(ST_Area(a.geom), ST_Area(b.geom))
			and a.part_id = p_part_id AND a.layer_id = p_layer_id AND a.object_id = p_object_id
			and b.part_id = p_part_id AND b.layer_id = p_layer_id AND b.object_id = p_object_id
        LIMIT 1;
        
        -- Если ничего не найдено, выходим
        IF NOT FOUND THEN
            EXIT;
        END IF;
        
        -- Обновляем геометрию первого полигона
        UPDATE road_processing.road_zones 
        SET geom = v_union_geom 
        WHERE zone_id = v_id1 AND part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id;
        
        GET DIAGNOSTICS merged = ROW_COUNT;
        
        -- Удаляем второй полигон
        DELETE FROM road_processing.road_zones 
        WHERE zone_id = v_id2 AND part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id;
        
    END LOOP;
	
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fill_road_parts(
    p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT,
    segment_len double precision default 1.0 -- длинна сегментов 
)
RETURNS VOID AS $$
BEGIN
	delete from road_processing.road_parts
	where part_id = p_part_id and layer_id = p_layer_id and object_id = p_object_id;
	
	WITH 
	original_road_part as (
		select p_part_id as id, geometry as geom
		from  road_processing.road_solid_parts
		where p_part_id = part_id  AND p_layer_id = layer_id  AND p_object_id = object_id
		),
	road_shards as(
        SELECT ST_Subdivide(ST_Segmentize(geom, segment_len)) as geom 
        FROM original_road_part
    )
--    select * from road_shards
    INSERT INTO road_processing.road_parts(part_id, layer_id, object_id, zone_id, id, geom)
    SELECT 
        p_part_id as part_id,
        p_layer_id as layer_id,
        p_object_id as object_id,
        NULL as zone_id,
        row_number() OVER() as id, 
        geom 
    FROM road_shards;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.fix_invalid_geometries(
    p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT
)
RETURNS VOID AS $$
BEGIN
--исправляем невалидные геометрии в road_parts
	UPDATE road_processing.road_parts
	SET geom = ST_MakeValid(geom)
	WHERE NOT ST_IsValid(geom) and part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id;
--удаляем невалидные гемотерии из road_parts
	DELETE FROM road_processing.road_parts
	WHERE (NOT ST_IsValid(geom)) and part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id;
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.road_part_classification(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT,
    intersection_area_weight double precision default 0.2, -- вес площади пересечения
    boundary_length_weight double precision default 0.2, -- вес длины границы
    centroid_distance_weight double precision default 0.2, -- вес расстояния между центроидами
    min_distance_weight double precision default 0.2, -- вес минимального расстояния
    lies_inside_weight double precision default 1.0 -- вес того лежит ли часть дороги целиком в зоне
    
)
RETURNS VOID AS $$
begin
WITH metrics AS (
    SELECT 
        rp.id AS shard_id,
        rp.geom AS shard_geom,
        rz.zone_id AS zone_id,
        rz.geom AS zone_geom,
        -- Площадь пересечения
        ST_Area(road_processing.safe_st_intersection(rp.geom, rz.geom)) AS intersection_area,
        -- Длина границы пересечения
        ST_Length(road_processing.safe_st_intersection(ST_Boundary(rp.geom), ST_Boundary(rz.geom))) AS boundary_length,
        -- Расстояние между центроидами
        ST_Distance(ST_Centroid(rp.geom), ST_Centroid(rz.geom)) AS centroid_distance,
        -- Расстояние между ближайшими точками
        ST_Distance(rp.geom, rz.geom) AS min_distance,
		-- лежит ли часть дороги целиком в зоне
        road_processing.safe_st_within(rp.geom, rz.geom) as lies_inside
   
    FROM road_processing.road_parts rp
    CROSS JOIN road_processing.road_zones rz
	where rp.part_id = p_part_id AND rp.layer_id = p_layer_id AND rp.object_id = p_object_id 
		and rz.part_id = p_part_id AND rz.layer_id = p_layer_id AND rz.object_id = p_object_id

),
--select * from metrics
-- Нормализуем метрики для взвешенной оценки
normalized_metrics AS (
    SELECT 
        shard_id,
        zone_id,
        intersection_area,
        boundary_length,
        centroid_distance,
        min_distance,
        lies_inside,
        
        -- Нормализация площади пересечения (чем больше, тем лучше)
        CASE 
            WHEN MAX(intersection_area) OVER (PARTITION BY shard_id) > 0 
            THEN intersection_area / MAX(intersection_area) OVER (PARTITION BY shard_id)
            ELSE 0 
        END AS norm_intersection_area,
        
        -- Нормализация длины границы (чем больше, тем лучше)
        CASE 
            WHEN MAX(boundary_length) OVER (PARTITION BY shard_id) > 0 
            THEN boundary_length / MAX(boundary_length) OVER (PARTITION BY shard_id)
            ELSE 0 
        END AS norm_boundary_length,
        
        -- Нормализация расстояния между центроидами (чем меньше, тем лучше)
        CASE 
            WHEN MAX(centroid_distance) OVER (PARTITION BY shard_id) > 0 
            THEN 1 - (centroid_distance / MAX(centroid_distance) OVER (PARTITION BY shard_id))
            ELSE 1 
        END AS norm_centroid_distance,
        
        -- Нормализация минимального расстояния (чем меньше, тем лучше)
        CASE 
            WHEN MAX(min_distance) OVER (PARTITION BY shard_id) > 0 
            THEN 1 - (min_distance / MAX(min_distance) OVER (PARTITION BY shard_id))
            ELSE 1 
        END AS norm_min_distance
        
    FROM metrics
),
--select * from normalized_metrics
-- Рассчитываем взвешенную оценку для каждой пары
scored_matches AS (
    SELECT 
        shard_id,
        zone_id,
        intersection_area,
        boundary_length,
        centroid_distance,
        min_distance,
        norm_intersection_area,
        norm_boundary_length,
        norm_centroid_distance,
        norm_min_distance,
        lies_inside,
        
        -- Взвешенная сумма метрик (веса можно настроить в зависимости от важности)
        (
            COALESCE(norm_intersection_area, 0) * intersection_area_weight +      -- вес площади пересечения 40%
            COALESCE(norm_boundary_length, 0) * boundary_length_weight +        -- вес длины границы 30%
            COALESCE(norm_centroid_distance, 0) * centroid_distance_weight +      -- вес расстояния между центроидами 20%
            COALESCE(norm_min_distance, 0) * min_distance_weight +            -- вес минимального расстояния 10%
            COALESCE(lies_inside, 0) * lies_inside_weight             -- лежит ли часть дороги целиком в зоне
        ) AS total_score
        
    FROM normalized_metrics
),
--select * from scored_matches
-- Выбираем лучшую зону для каждой части дороги
best_matches AS (
    SELECT DISTINCT ON (shard_id)
        shard_id,
        zone_id,
        total_score,
        intersection_area,
        boundary_length,
        centroid_distance,
        min_distance,
        norm_intersection_area,
        norm_boundary_length,
        norm_centroid_distance,
        norm_min_distance
    FROM scored_matches
    ORDER BY shard_id, total_score DESC
)
--select * from best_matches
-- Обновляем таблицу road_parts, присваивая zone_id
UPDATE road_processing.road_parts rp
SET zone_id = bm.zone_id
FROM best_matches bm
WHERE rp.id = bm.shard_id AND rp.part_id = p_part_id AND rp.layer_id = p_layer_id
	 AND rp.object_id = p_object_id;	
END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.merge_small_intersected_zones(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT,
    max_area DOUBLE PRECISION DEFAULT 20000,		-- максимальная площадь любого полигона
    max_length DOUBLE PRECISION DEFAULT 350,		-- максимальная длинна любого полигона
    min_area DOUBLE PRECISION DEFAULT 5000,      -- полигоны меньше этой площади считаются "малыми"
    min_length DOUBLE PRECISION DEFAULT 150      -- полигоны меньше этого размера также считаются "малыми"
)
--RETURNS INTEGER AS $$
RETURNS VOID AS $$
DECLARE
	merged INTEGER;
    v_small_id INTEGER;
    v_target_id INTEGER;
    v_new_geom GEOMETRY(GEOMETRY, 3857);
    v_small_geom GEOMETRY(GEOMETRY, 3857);
    v_small_area DOUBLE PRECISION;
    v_small_length DOUBLE PRECISION;
BEGIN
    LOOP
        -- Находим один малый полигон (по площади или линейному размеру)
        SELECT 
            zone_id, 
            geom,
            ST_Area(geom),
            ST_MaxDistance(geom, geom)  -- приблизительный линейный размер
        INTO 
            v_small_id,
            v_small_geom,
            v_small_area,
            v_small_length
        FROM road_processing.road_partition
        WHERE (
--			ST_Area(geom) <= min_area OR	
		 	ST_MaxDistance(geom, geom) <= min_length)
			and part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id 
			 AND ST_IsValid(geom) 
        LIMIT 1;
        
--         Если малых полигонов нет - выходим
        IF NOT FOUND THEN
            EXIT;
        END IF;
        
--         Ищем пересекающийся полигон с НАИМЕНЬШЕЙ бы полученной площадью и длине
        SELECT 
            b.zone_id,
            road_processing.safe_st_union(v_small_geom, b.geom)
        INTO 
            v_target_id,
            v_new_geom
        FROM road_processing.road_partition b
        WHERE b.zone_id != v_small_id
			and road_processing.safe_st_intersects(v_small_geom, b.geom)
--          AND ST_Intersects(v_small_geom, b.geom) 
		  and part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id
-- выбираем наименьший по площади и длине полигон
        ORDER BY 
			 (COALESCE(ST_MaxDistance(v_small_geom, v_small_geom), 0) + 
             COALESCE(ST_MaxDistance(b.geom, b.geom), 0)) * 0.5 + 
            (COALESCE(ST_Area(v_small_geom), 0) + COALESCE(ST_Area(b.geom), 0)) * 0.5 ASC
        LIMIT 1;
        
        -- Если ничего не найдено, выходим
        IF NOT FOUND THEN
            EXIT;
        END IF;
        
        -- Обновляем геометрию первого полигона
        UPDATE road_processing.road_partition 
        SET geom = v_new_geom 
        WHERE zone_id = v_target_id and part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id;
        
        GET DIAGNOSTICS merged = ROW_COUNT;
        
        -- Удаляем малый полигон
        DELETE FROM road_processing.road_partition WHERE zone_id = v_small_id and part_id = p_part_id AND layer_id = p_layer_id AND object_id = p_object_id;

    END LOOP;

END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.make_part_of_road_segmentation(
	p_part_id INTEGER,
    p_layer_id INTEGER,
    p_object_id TEXT,
    
    standart_segment_len DOUBLE PRECISION DEFAULT 300, -- желаемая длинна сегмента дороги
    standart_segment_wide DOUBLE PRECISION DEFAULT 50, -- предполагаемая ширина дороги
    max_segment_area DOUBLE PRECISION DEFAULT 20000,	-- максимальная площадь любого полигона
    max_segment_length DOUBLE PRECISION DEFAULT 350,	-- максимальная длинна любого полигона
    min_segment_area DOUBLE PRECISION DEFAULT 5000,     -- полигоны меньше этой площади считаются "малыми"
    min_segment_length DOUBLE PRECISION DEFAULT 150,     -- полигоны меньше этого размера также считаются "малыми"
    merge_area_tolerance_percent DOUBLE PRECISION DEFAULT 50, -- процентный порог зон для их слияния по общей площади их пересечения
	intersection_area_weight double precision default 0.2, -- вес площади пересечения для функции классфикации шарда road_part_classification
    boundary_length_weight double precision default 0.2, -- вес длины границы для функции классфикации шарда road_part_classification
    centroid_distance_weight double precision default 0.2, -- вес расстояния между центроидами для функции классфикации шарда road_part_classification
    min_distance_weight double precision default 0.2, -- вес минимального расстояния для функции классфикации шарда road_part_classification
    lies_inside_weight double precision default 1.0, -- вес того лежит ли часть дороги целиком в зоне для функции классфикации шарда road_part_classification
    topology_distance_tolerance DOUBLE PRECISION DEFAULT 2.0, 		--  параметр для функции generate_road_skeleton - дистанция в ST_SimplifyPreserveTopology
    shard_segment_len DOUBLE PRECISION DEFAULT 1.0, -- длинна "осколка" дороги. Функция fill_road_parts, параметр для ST_Segmentize
    buffer_distance DOUBLE PRECISION DEFAULT 1.0, -- величина буффер для функции ST_Buffer в process_again_and_get_better_zones
    buffer_distance_for_group_zones DOUBLE PRECISION DEFAULT 0.01, -- величина буфера в функции группировки классифицированных шардов
    topology_distance_tolerance_for_group_zones DOUBLE PRECISION default 0.01, -- величина допуска в функции группировки классифицированных шардов
    grid_size_for_group_zones DOUBLE PRECISION default 0.1, --величина сетки в функции группировки классифицированных шардов
    unsuitable_road_zones_area_threshold double precision default 100, -- избавляемся от зон с меньшей площадью
    unsuitable_road_zones_len_threshold double precision default 100  -- избавляемся от зон с меньшей длинной
)
RETURNS VOID AS $$
DECLARE
	v_should_skip boolean;
begin	
--  стоит ли пропустить разбивку дороги и сразу добавить в результирующую таблицу
	select road_processing.should_skip_segmentation(p_part_id, p_layer_id, p_object_id, max_segment_length) into v_should_skip;
	if v_should_skip
		then perform road_processing.skip_segmentation_and_fill_final_road_partition(p_part_id, p_layer_id, p_object_id)
		return;
	end if;

	PERFORM  road_processing.generate_road_skeleton(p_part_id, p_layer_id, p_object_id, topology_distance_tolerance);
--	извлекаем сегменты(отдельные линии/отрезки) из "скелета" дороги
	PERFORM  road_processing.fill_road_segments(p_part_id, p_layer_id, p_object_id);
-- находим все соеденительные точки "скелета" дороги
	PERFORM  road_processing.fill_road_vertices(p_part_id, p_layer_id, p_object_id);
-- обновляем колонки source и target таблицы road_segments
	PERFORM  road_processing.update_road_segments(p_part_id, p_layer_id, p_object_id);
-- находим вершины(листья, конечные узлы) "скелета" дороги
	PERFORM  road_processing.fill_leaf_nodes(p_part_id, p_layer_id, p_object_id);
-- вычисляем матрицу расстояний между всеми конечными узалми leaf_cost_matrix
	PERFORM  road_processing.fill_leaf_cost_matrix(p_part_id, p_layer_id, p_object_id);
-- вычисляем диаметр дерева - самое длинное кратчайшее расстояние
	PERFORM  road_processing.fill_diameter_info(p_part_id, p_layer_id, p_object_id);
-- получаем геометрию диаметра - центральную осевую линию дороги
	PERFORM  road_processing.fill_final_longest_route(p_part_id, p_layer_id, p_object_id);
-- получаем зоны разбиения дороги
	PERFORM  road_processing.fill_road_zones(p_part_id, p_layer_id, p_object_id, standart_segment_len, standart_segment_wide);
	
-- заносим полученные зоны, заново обрабатываем их как полигон для лучшего получения зон
   PERFORM road_processing.process_again_and_get_better_zones(p_part_id => p_part_id, p_layer_id => p_layer_id, p_object_id => p_object_id, standart_segment_len => standart_segment_len, standart_segment_wide => standart_segment_wide,
merge_area_tolerance_percent => merge_area_tolerance_percent, buffer_distance => buffer_distance, 
topology_distance_tolerance => topology_distance_tolerance);
	
-- сливаем сильно перескающиеся по площади зоны
	PERFORM  road_processing.merge_overlapping_zones(p_part_id, p_layer_id, p_object_id, merge_area_tolerance_percent);
	
---- выделяем пересечения/наложения зон также в качестве обычных зон
road_processing.split_overlapped_zones(p_part_id, p_layer_id, p_object_id);

---- разбиваем исходную дорогу на части
    PERFORM road_processing.fill_road_parts(p_part_id, p_layer_id, p_object_id, shard_segment_len);

-- исправляем/удаляем невалидные геометрии
	PERFORM  road_processing.fix_invalid_geometries(p_part_id, p_layer_id, p_object_id);
---- удаляем неподхядящие геометрии из road_parts
	PERFORM road_processing.remove_unsuitable_road_parts(p_part_id, p_layer_id, p_object_id);
---- удаляем неподходящие зоны
	PERFORM road_processing.remove_unsuitable_road_zones(p_part_id, p_layer_id, p_object_id, 
			unsuitable_road_zones_area_threshold => unsuitable_road_zones_area_threshold,
			unsuitable_road_zones_len_threshold => unsuitable_road_zones_len_threshold);
----	проводим классфикацию кусочков дороги

	PERFORM  road_processing.road_part_classification(p_part_id, p_layer_id, p_object_id,
		intersection_area_weight, boundary_length_weight, centroid_distance_weight,
		min_distance_weight, lies_inside_weight);
	
	perform road_processing.group_zones_for_road_partition (p_part_id => p_part_id, 
			p_layer_id => p_layer_id, p_object_id => p_object_id,
			buffer_distance_for_group_zones => buffer_distance_for_group_zones,
			topology_distance_tolerance_for_group_zones => topology_distance_tolerance_for_group_zones,
			grid_size_for_group_zones => grid_size_for_group_zones);
	
---- сливаем малые зоны 
	PERFORM  road_processing.merge_small_intersected_zones(p_part_id, p_layer_id, p_object_id,
		max_segment_area, max_segment_length, min_segment_area, min_segment_length);
---- записываем результат в таблицу final_road_partition
	PERFORM  road_processing.fill_final_road_partition(p_part_id, p_layer_id, p_object_id);

END;
$$ LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION road_processing.main_road_segmentation(
    p_layer_id INTEGER,
    p_object_id TEXT,
    standart_segment_len DOUBLE PRECISION DEFAULT 300,
    standart_segment_wide DOUBLE PRECISION DEFAULT 50,
    max_segment_area DOUBLE PRECISION DEFAULT 20000,
    max_segment_length DOUBLE PRECISION DEFAULT 350,
    min_segment_area DOUBLE PRECISION DEFAULT 5000,
    min_segment_length DOUBLE PRECISION DEFAULT 150,
    merge_area_tolerance_percent DOUBLE PRECISION DEFAULT 50,
    intersection_area_weight DOUBLE PRECISION DEFAULT 0.2,
    boundary_length_weight DOUBLE PRECISION DEFAULT 0.2,
    centroid_distance_weight DOUBLE PRECISION DEFAULT 0.2,
    min_distance_weight DOUBLE PRECISION DEFAULT 0.2,
    lies_inside_weight DOUBLE PRECISION DEFAULT 1.0,
    topology_distance_tolerance DOUBLE PRECISION DEFAULT 2.0,
    shard_segment_len DOUBLE PRECISION DEFAULT 1.0,
    unsuitable_road_zones_area_threshold double precision default 100, 
    unsuitable_road_zones_len_threshold double precision default 100  
)
RETURNS VOID AS $$
DECLARE
    road_part_record RECORD;
BEGIN
	-- Заносим части Multipolygon (мультиполигона) как отдельные part_id в таблицу source_road_solid_parts
	PERFORM road_processing.fill_source_road_solid_parts_multipolygon(p_layer_id, p_object_id);
    
    -- Заносим все части дороги из таблицы source_road_solid_parts в road_solid_parts
    PERFORM road_processing.fill_road_solid_parts(p_layer_id, p_object_id);
    
    -- Удаляем старое разбиение дороги
    PERFORM road_processing.delete_from_final_road_partition(p_layer_id, p_object_id);
    
    -- Выполняем основное разбиение дороги по каждой части
    FOR road_part_record IN 
        SELECT DISTINCT part_id 
        FROM road_processing.road_solid_parts
        WHERE layer_id = p_layer_id AND object_id = p_object_id
    LOOP
        PERFORM road_processing.make_part_of_road_segmentation(
            p_part_id => road_part_record.part_id,
            p_layer_id => p_layer_id,
            p_object_id => p_object_id,
            standart_segment_len => standart_segment_len,
            standart_segment_wide => standart_segment_wide,
            max_segment_area => max_segment_area,
            max_segment_length => max_segment_length,
            min_segment_area => min_segment_area,
            min_segment_length => min_segment_length,
            merge_area_tolerance_percent => merge_area_tolerance_percent,
            intersection_area_weight => intersection_area_weight,
            boundary_length_weight => boundary_length_weight,
            centroid_distance_weight => centroid_distance_weight,
            min_distance_weight => min_distance_weight,
            lies_inside_weight => lies_inside_weight,
            topology_distance_tolerance => topology_distance_tolerance,
            shard_segment_len => shard_segment_len
        );
    END LOOP;
END;
$$ LANGUAGE plpgsql;