Comptime

  pub fn MyStruct(comptime T: type) type {
      return struct {
          const Self = @This();

          myNumber: T,

          pub fn structFunction(writer: anytype) !void {
              try writer.print("structFunction\n", .{});
          }

          pub fn instanceFunction(self: *Self, writer: anytype) !void {
              try writer.print("structInstance: {d}\n", .{self.myNumber});
          }
      };
  }

  pub fn main() !void {
      const stdout = std.io.getStdOut().writer();

      try MyStruct(f32).structFunction(stdout);

      var myStruct = MyStruct(f32){
          .myNumber = 42,
      };

      try myStruct.instanceFunction(stdout);
  }

  fn MyStruct(comptime T: type) type {
      return struct {
          myNumber: T,
      };
  }

  pub fn main() !void {
      // The structure name is infered
      const myStruct1 = MyStruct(i32) {
          .myNumber = 42,
      };
      _ = myStruct1;

      // The structure has a explicit name
      const intStruct = MyStruct(i32);
      const myStruct2 =  intStruct {
          .myNumber = 42,
      };
      _ = myStruct2;
  }

  pub fn LinkedList(comptime T: type) type {
      return struct {
          const Node = struct {
              data: T,
              prev: ?*Node,
              next: ?*Node,
          };

          const LinkedListError = error{headNull};
          const Self = @This();
          allocator: std.mem.Allocator,
          head: ?*Node,
          len: u32 = 0,

          pub fn init(allocator: std.mem.Allocator) Self {
              return Self{
                  .head = null,
                  .allocator = allocator,
              };
          }

          pub fn deinit(self: *Self) void {
              var curr = self.head;

              while (curr) |currNotNull| {
                  const node = currNotNull;
                  curr = currNotNull.next;
                  self.allocator.destroy(node);
              }
              self.len = 0;
          }

          pub fn push(self: *Self, value: T) !void {
              var node = try self.allocator.create(Node);
              node.*.data = value;
              self.len += 1;

              if (self.head) |head| {
                  node.next = head;
                  head.prev = node;
                  self.head = node;
              } else {
                  self.head = node;
                  node.*.next = null;
                  node.*.prev = null;
              }
          }
      };
  }

  test "Should push one item into a i32 list" {
      const intLinkedList = LinkedList(i32);
      var list = intLinkedList.init(std.testing.allocator);
      defer list.deinit();

      const expected = 42;

      try list.push(expected);
      const result = list.head.?.data;

      try std.testing.expect(expected == result);
  }

  test "Should push one item into a f32 list" {
      const intLinkedList = LinkedList(f32);
      var list = intLinkedList.init(std.testing.allocator);
      defer list.deinit();

      const expected = 3.1415;

      try list.push(expected);
      const result = list.head.?.data;

      try std.testing.expect(expected == result);
  }

  pub fn CsvWriter(comptime T: type) type {
      return struct {
          const Self = @This();

          const Config = struct {
              separator: u8 = ',',
          };
          config: Config,

          pub fn init(config: Config) Self {
              return Self{
                  .config = config,
              };
          }

          pub fn stringify(self: *Self, arrayList: *std.ArrayList(T), writer: anytype) !void {
              try writeHeader(self, &writer);
              for (arrayList.items) |item| {
                  try writeType(self, item, &writer);
              }
          }

          fn writeHeader(self: *Self, writer: anytype) !void {
              const fields = std.meta.fields(T);

              inline for (fields, 1..) |field, i| {
                  try writer.print("{s}", .{field.name});
                  if (fields.len != i) {
                      try writer.print("{c}", .{self.config.separator});
                  }
              }
              try writer.print("\n", .{});
          }

          fn writeType(self: *Self, item: T, writer: anytype) !void {
              const fields = std.meta.fields(T);

              if (@TypeOf(fields) != []const std.builtin.Type.StructField)
                  @compileError("The type is not the a struct");

              inline for (fields, 1..) |field, i| {
                  const f = @field(item, field.name);

                  switch (@typeInfo(@TypeOf(f))) {
                      .Int => try writer.print("{d}", .{f}),
                      .Float => try writer.print("{d}", .{f}),
                      .Pointer => |pointer| {
                          if (pointer.size == std.builtin.Type.Pointer.Size.Slice and pointer.child == u8) {
                              try writer.print("{s}", .{f});
                          } else {
                              @compileError("Currently, the CsvWriter dosen't support complex types");
                          }
                      },
                      else => @compileError("Currently, the CsvWriter dosen't support complex types"),
                  }

                  if (fields.len != i) {
                      try writer.print("{c}", .{self.config.separator});
                  }
              }
              try writer.print("\n", .{});
          }
      };
  }

  const Person = struct {
      sexe: []const u8,
      name: []const u8,
      date: u32,
  };


  pub fn main() !void {
      const stdout = std.io.getStdOut().writer();
      var gpa = std.heap.GeneralPurposeAllocator(.{}){};

      const person1 = .{ .sexe = "M", .name = "Lucas", .date = 2000 };
      const person2 = .{ .sexe = "F", .name = "Ava", .date = 2020 };
      const person3 = .{ .sexe = "F", .name = "Sophia", .date = 1989 };

      var arrayList = std.ArrayList(Person).init(gpa.allocator());
      defer arrayList.deinit();

      try arrayList.append(person1);
      try arrayList.append(person2);
      try arrayList.append(person3);

      var buffer: [1024]u8 = undefined;
      var stream = std.io.fixedBufferStream(buffer[0..]);

      const personCsvWriter = CsvWriter(Person);
      var csv = personCsvWriter.init(.{ .separator = ' ' });
      try csv.stringify(&arrayList, stream.writer());

      try stdout.print("{s}", .{stream.getWritten()});

  }