data class PortRouteSelector(val ports: List<IntRange>) : RouteSelector(RouteSelectorEvaluation.qualityConstant) {
    override fun evaluate(context: RoutingResolveContext, segmentIndex: Int): RouteSelectorEvaluation {
        val callPort = context.call.request.local.port

        return if (ports.any { callPort in it }) {
            RouteSelectorEvaluation.Constant
        } else {
            RouteSelectorEvaluation.Failed
        }
    }
}

fun Route.localPort(vararg ports: Int, block: Route.() -> Unit): Route {
    return createChild(PortRouteSelector(ports.map { it..it })).apply(block)
}

fun main(args: Array<String>) {
    val env = applicationEngineEnvironment {
        module { 
            main()
        }
        connector {
            port = 9090
        }
        connector {
            port = 8080
        }
        sslConnector() {
            port = 8443
        }
    }
    embeddedServer(Netty, env).start(true)
}

/**
 * Creates an embedded server with the given [factory], listening on [endpoints] list of Pair(host, port)
 * @param watchPaths specifies path substrings that will be watched for automatic reloading
 * @param configure configuration script for the engine
 * @param module application module function
 */
fun <TEngine : ApplicationEngine, TConfiguration : ApplicationEngine.Configuration>
        embeddedServer(factory: ApplicationEngineFactory<TEngine, TConfiguration>,
                       endpoints: List<Pair<String, Int>> =  listOf(Pair("0.0.0.0", 80)),
                       watchPaths: List<String> = emptyList(),
                       configure: TConfiguration.() -> Unit = {},
                       module: Application.() -> Unit): TEngine {
    val environment = applicationEngineEnvironment {
        this.log = LoggerFactory.getLogger("ktor.application")
        this.watchPaths = watchPaths
        this.module(module)

        endpoints.forEach { endpoint ->
            connector {
                this.port = endpoint.first
                this.host = endpoint.second
            }
        }

    }

    return embeddedServer(factory, environment, configure)
}