модуль маршрутизатор

импорт "стд::контейнеры/словарь/стр-стр"
импорт "исх/строка"
импорт "исх/сеть/хттп"
импорт "исх/массивы"

тип Обращение* = класс (хттп.ХттпОбращение) {
    запрос-в-пути*: стр-стр.Словарь := стр-стр.Словарь{}
}

тип ОбработчикМаршрута = фн (путь: Строка, параметры: массивы.Строки, обращение: Обращение): хттп.ХттпОтвет

тип Маршрут = класс {
    путь: Строка := "/"
    обработчик: ОбработчикМаршрута := позже
    методы: массивы.Строки := массивы.Строки[]
}

фн (м: Маршрут) подходит по пути(обращение: хттп.ХттпОбращение, параметры := массивы.Строки): Лог {
    пусть части пути по запросу = строка.разобрать(обращение.путь, "?")
    пусть части пути обращения = строка.разобрать(части пути по запросу[0], "/")
    пусть части пути маршрута = строка.разобрать(м.путь, "/")

    цикл [номер]часть пути маршрута среди части пути маршрута {
        если часть пути маршрута = "*" {
            пусть ай := номер

            пока ай < длина(части пути обращения) {
                параметры.добавить(части пути обращения[ай])
                ай++
            }

            вернуть истина
        }

        если номер >= длина(части пути обращения) {
            вернуть ложь
        }

        пусть часть пути обращения = части пути обращения[номер]

        если часть пути маршрута = "$" {
            параметры.добавить(часть пути обращения)
        } иначе если часть пути маршрута # часть пути обращения {
            вернуть ложь
        }
    }

    вернуть длина(части пути маршрута) = длина(части пути обращения)
}

фн (м: Маршрут) подходит по методу(обращение: хттп.ХттпОбращение): Лог {
    цикл [номер]метод среди м.методы {
        если метод = обращение.метод {
            вернуть истина
        }
    }

    вернуть ложь
}

фн (м: Маршрут) подходит для*(обращение: хттп.ХттпОбращение, параметры := массивы.Строки): Лог {
    вернуть м.подходит по пути(обращение, параметры) & м.подходит по методу(обращение)
}

тип Маршруты = []Маршрут

тип Маршрутизатор* = класс {
    маршруты: Маршруты := Маршруты[]
    обработчик_404: ОбработчикМаршрута := обработчик_404
}

фн (м: Маршрутизатор) добавить маршрут*(путь: Строка, методы: массивы.Строки, обработчик: ОбработчикМаршрута) {
    м.маршруты.добавить(Маршрут{путь: путь, обработчик: обработчик, методы: методы})
}

фн (м: Маршрутизатор) обработать обращение*(обращение: хттп.ХттпОбращение): хттп.ХттпОтвет {
    пусть обращение маршрутизатора = Обращение{
        метод: обращение.метод,
        путь: обращение.путь,
        версия: обращение.версия,
        заглавия: обращение.заглавия,
        туловище: обращение.туловище,
        запрос-в-пути: разобрать-запрос-в-пути(обращение.путь)
    }

    цикл [номер]маршрут среди м.маршруты {
        пусть параметры := массивы.Строки[]

        если маршрут.подходит для(обращение, параметры) {
            вернуть маршрут.обработчик(обращение.путь, параметры, обращение маршрутизатора)
        }
    }

    вернуть м.обработчик_404(обращение.путь, массивы.Строки[], обращение маршрутизатора)
}

фн разобрать-запрос-в-пути(путь: Строка): стр-стр.Словарь {
    пусть части = строка.разобрать(путь, "?")

    если длина(части) < 2 {
        вернуть стр-стр.Словарь{}
    }

    пусть параметры = строка.разобрать(части[1], "&")
    пусть словарь = стр-стр.Словарь{}

    цикл [номер]параметр среди параметры {
        пусть пара = строка.разобрать(параметр, "=")

        если длина(пара) = 2 {
            словарь.добавить(пара[0], пара[1])
        } иначе если длина(пара) = 1 {
            словарь.добавить(пара[0], "")
        }
    }

    вернуть словарь
}