using Astralis;
using Invercargill;
using Invercargill.DataStructures;

/**
 * DataStructuresDemo Example
 * 
 * Demonstrates various Invercargill data structures.
 * Shows how to use Series, Vector, RingBuffer, and other structures
 * with the Astralis web framework.
 */

// Root handler
class RootEndpoint : Object, Endpoint {
    public async HttpResult handle_request(HttpContext http_context, RouteContext route) throws Error {
        return new HttpStringResult("""Data Structures Demo

This example demonstrates various Invercargill data structures:

Endpoints:
  GET /series                - Series operations
  GET /vector                - Vector operations
  GET /ring-buffer           - RingBuffer operations
  GET /immutable-buffer      - ImmutableBuffer operations
  GET /wrap-operations       - Wrap utility functions
  GET /combined-operations   - Combined operations
""");
    }
}

// Series operations
class SeriesEndpoint : Object, Endpoint {
    public async HttpResult handle_request(HttpContext http_context, RouteContext route) throws Error {
        var series_array = new string[3];
        series_array[0] = "First";
        series_array[1] = "Second";
        series_array[2] = "Third";
        
        var parts = new Series<string>();
        parts.add_start("Series contents: ");
        
        foreach (var item in series_array) {
            parts.add_start(item + " ");
        }
        
        var count = series_array.length;
        parts.add_start("\nCount: " + count.to_string());
        
        var result = parts.to_immutable_buffer()
            .aggregate<string>("", (acc, s) => acc + s);
        
        return new HttpStringResult(result);
    }
}

// Vector operations
class VectorEndpoint : Object, Endpoint {
    public async HttpResult handle_request(HttpContext http_context, RouteContext route) throws Error {
        var numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        
        var vector = Wrap.array<int>(numbers).as_enumerable().to_vector();
        
        var count = vector.count();
        var first = vector.first_or_default(n => true);
        var last = vector.last_or_default(n => true);
        
        var result = @"Vector operations:
  Count: $count
  First: $first
  Last: $last
  Elements: 1, 2, 3, 4, 5";
        
        return new HttpStringResult(result);
    }
}

// RingBuffer operations
class RingBufferEndpoint : Object, Endpoint {
    public async HttpResult handle_request(HttpContext http_context, RouteContext route) throws Error {
        var buffer_array = new string[5];
        buffer_array[0] = "Item 1";
        buffer_array[1] = "Item 2";
        buffer_array[2] = "Item 3";
        buffer_array[3] = "Item 4";
        buffer_array[4] = "Item 5";
        
        var buffer = Wrap.array<string>(buffer_array).as_enumerable().to_ring_buffer(3);
        
        var count = buffer.count();
        
        var result = @"RingBuffer operations:
  Size: 3
  Count: $count
  Note: RingBuffer automatically overwrites old items when full";
        
        return new HttpStringResult(result);
    }
}

// ImmutableBuffer operations
class ImmutableBufferEndpoint : Object, Endpoint {
    public async HttpResult handle_request(HttpContext http_context, RouteContext route) throws Error {
        var items_array = new string[4];
        items_array[0] = "Apple";
        items_array[1] = "Banana";
        items_array[2] = "Cherry";
        items_array[3] = "Date";
        
        var buffer = Wrap.array<string>(items_array).as_enumerable().to_immutable_buffer();
        
        var count = buffer.count();
        
        var parts = new Series<string>();
        parts.add_start("ImmutableBuffer contents: ");
        
        buffer.iterate((item) => {
            parts.add_start(item + " ");
        });
        
        parts.add_start("\nCount: " + count.to_string());
        
        var result = parts.to_immutable_buffer()
            .aggregate<string>("", (acc, s) => acc + s);
        
        return new HttpStringResult(result);
    }
}

// Wrap utility functions
class WrapOperationsEndpoint : Object, Endpoint {
    public async HttpResult handle_request(HttpContext http_context, RouteContext route) throws Error {
        var numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;
        
        var strings = new string[5];
        strings[0] = "one";
        strings[1] = "two";
        strings[2] = "three";
        strings[3] = "four";
        strings[4] = "five";
        
        var num_count = Wrap.array<int>(numbers).as_enumerable().count();
        var str_count = Wrap.array<string>(strings).as_enumerable().count();
        
        var result = @"Wrap operations:
  Array of ints count: $num_count
  Array of strings count: $str_count
  Numbers: 1, 2, 3, 4, 5
  Strings: one, two, three, four, five";
        
        return new HttpStringResult(result);
    }
}

// Combined operations
class CombinedOperationsEndpoint : Object, Endpoint {
    public async HttpResult handle_request(HttpContext http_context, RouteContext route) throws Error {
        var numbers1 = new int[3];
        numbers1[0] = 1;
        numbers1[1] = 2;
        numbers1[2] = 3;
        
        var numbers2 = new int[3];
        numbers2[0] = 4;
        numbers2[1] = 5;
        numbers2[2] = 6;
        
        var concatenated = Wrap.array<int>(numbers1).as_enumerable()
            .concat(Wrap.array<int>(numbers2).as_enumerable());
        
        var sum = concatenated.aggregate<int>(0, (acc, n) => acc + n);
        var avg = (double)sum / concatenated.count();
        
        var filtered = concatenated.where(n => n > 2);
        var sorted = filtered.order_by<int>(n => n);
        
        var parts = new Series<string>();
        parts.add_start("Combined operations:\n");
        parts.add_start("Original arrays: [1,2,3] and [4,5,6]\n");
        parts.add_start("Concatenated: ");
        parts.add_start(enumerable_int_to_string(concatenated));
        parts.add_start("\n");
        parts.add_start(@"Sum: $sum\n");
        parts.add_start(@"Average: $avg\n");
        parts.add_start("Filtered (>2): ");
        parts.add_start(enumerable_int_to_string(filtered));
        parts.add_start("\n");
        parts.add_start("Sorted: ");
        parts.add_start(enumerable_int_to_string(sorted));
        
        var result = parts.to_immutable_buffer()
            .aggregate<string>("", (acc, s) => acc + s);
        
        return new HttpStringResult(result);
    }
}

void main() {
    var application = new WebApplication(8086);
    
    application.container.register_scoped<Endpoint>(() => new RootEndpoint())
        .with_metadata<EndpointRoute>(new EndpointRoute("/"));
    
    application.container.register_scoped<Endpoint>(() => new SeriesEndpoint())
        .with_metadata<EndpointRoute>(new EndpointRoute("/series"));
    
    application.container.register_scoped<Endpoint>(() => new VectorEndpoint())
        .with_metadata<EndpointRoute>(new EndpointRoute("/vector"));
    
    application.container.register_scoped<Endpoint>(() => new RingBufferEndpoint())
        .with_metadata<EndpointRoute>(new EndpointRoute("/ring-buffer"));
    
    application.container.register_scoped<Endpoint>(() => new ImmutableBufferEndpoint())
        .with_metadata<EndpointRoute>(new EndpointRoute("/immutable-buffer"));
    
    application.container.register_scoped<Endpoint>(() => new WrapOperationsEndpoint())
        .with_metadata<EndpointRoute>(new EndpointRoute("/wrap-operations"));
    
    application.container.register_scoped<Endpoint>(() => new CombinedOperationsEndpoint())
        .with_metadata<EndpointRoute>(new EndpointRoute("/combined-operations"));
    
    print("Data Structures Demo Server running on port 8086\n");
    print("Try these endpoints:\n");
    print("  - http://localhost:8086/\n");
    print("  - http://localhost:8086/series\n");
    print("  - http://localhost:8086/vector\n");
    print("  - http://localhost:8086/ring-buffer\n");
    print("  - http://localhost:8086/immutable-buffer\n");
    print("  - http://localhost:8086/wrap-operations\n");
    print("  - http://localhost:8086/combined-operations\n");
    
    application.run();
}

// Helper functions

string enumerable_int_to_string(Enumerable<int> enumerable) {
    return enumerable.to_immutable_buffer()
        .aggregate<string>("[", (acc, n) => {
            if (acc == "[") return acc + n.to_string();
            return acc + ", " + n.to_string();
        }) + "]";
}