// Grid breakpoints
$grid-breakpoints: (
  xs: 0,
  sm: 576px,
  md: 768px,
  lg: 992px,
  xl: 1200px,
  xxl: 1400px,
) !default;

// Maximum container sizes
$container-max-widths: (
  sm: 540px,
  md: 720px,
  lg: 960px,
  xl: 1140px,
  xxl: 1320px,
) !default;

// Grid columns
$grid-columns: 12 !default;
$grid-gutter-width: 1.5rem !default;
$grid-row-columns: 6 !default;

// Container padding
$container-padding-x: $grid-gutter-width * 0.5 !default;

// Mixins for responsive breakpoints
@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {
  $min: map-get($breakpoints, $name);
  @if $min != 0 {
    @media (min-width: $min) {
      @content;
    }
  } @else {
    @content;
  }
}

@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {
  $max: map-get($breakpoints, $name);
  @if $max != 0 {
    @media (max-width: $max - 0.02) {
      @content;
    }
  }
}

@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {
  $min: map-get($breakpoints, $lower);
  $max: map-get($breakpoints, $upper);

  @if $min != 0 and $max != 0 {
    @media (min-width: $min) and (max-width: $max - 0.02) {
      @content;
    }
  } @else if $max == 0 {
    @include media-breakpoint-up($lower, $breakpoints) {
      @content;
    }
  } @else if $min == 0 {
    @include media-breakpoint-down($upper, $breakpoints) {
      @content;
    }
  }
}

@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {
  $min: map-get($breakpoints, $name);
  $next: map-get($breakpoints, $name);
  $max: map-get($breakpoints, $next);

  @if $min != 0 and $max != 0 {
    @media (min-width: $min) and (max-width: $max - 0.02) {
      @content;
    }
  } @else if $max == 0 {
    @include media-breakpoint-up($name, $breakpoints) {
      @content;
    }
  } @else if $min == 0 {
    @include media-breakpoint-down($next, $breakpoints) {
      @content;
    }
  }
}

// Container mixins
@mixin make-container($padding-x: $container-padding-x) {
  width: 100%;
  padding-right: $padding-x;
  padding-left: $padding-x;
  margin-right: auto;
  margin-left: auto;
}

// Row mixin
@mixin make-row($gutter: $grid-gutter-width) {
  display: flex;
  flex-wrap: wrap;
  margin-top: calc(-1 * #{$gutter} * 0.5);
  margin-right: calc(-0.5 * #{$gutter});
  margin-left: calc(-0.5 * #{$gutter});
}

// Column mixin
@mixin make-col-ready() {
  box-sizing: border-box;
  flex-shrink: 0;
  width: 100%;
  max-width: 100%;
  padding-right: calc(#{$grid-gutter-width} * 0.5);
  padding-left: calc(#{$grid-gutter-width} * 0.5);
  margin-top: calc(#{$grid-gutter-width} * 0.5);
}

@mixin make-col($size: false, $columns: $grid-columns) {
  @if $size {
    flex: 0 0 auto;
    width: percentage(calc($size / $columns));
  } @else {
    flex: 1 1 0;
    max-width: 100%;
  }
}

@mixin make-col-auto() {
  flex: 0 0 auto;
  width: auto;
}

@mixin make-col-offset($size, $columns: $grid-columns) {
  $num: calc($size / $columns);
  margin-left: if($num == 0, 0, percentage($num));
}

// Base container styles
.container,
.container-fluid,
.container-sm,
.container-md,
.container-lg,
.container-xl,
.container-xxl {
  @include make-container();
}

// Responsive containers
@each $breakpoint, $container-max-width in $container-max-widths {
  .container-#{$breakpoint} {
    @extend .container-fluid;
  }

  @include media-breakpoint-up($breakpoint, $grid-breakpoints) {
    %responsive-container-#{$breakpoint} {
      max-width: $container-max-width;
    }

    .container,
    .container-#{$breakpoint} {
      @extend %responsive-container-#{$breakpoint};
    }
  }
}

// Row
.row {
  @include make-row();

  > * {
    @include make-col-ready();
  }
}

// Columns
.col {
  @include make-col();
}

@for $i from 1 through $grid-columns {
  .col-#{$i} {
    @include make-col($i, $grid-columns);
  }
}

.col-auto {
  @include make-col-auto();
}

@each $breakpoint in map-keys($grid-breakpoints) {
  $infix: if($breakpoint == xs, '', '-#{$breakpoint}');

  @include media-breakpoint-up($breakpoint, $grid-breakpoints) {
    .col#{$infix} {
      @include make-col();
    }

    .col#{$infix}-auto {
      @include make-col-auto();
    }

    @for $i from 1 through $grid-columns {
      .col#{$infix}-#{$i} {
        @include make-col($i, $grid-columns);
      }
    }

    // Offsets
    @for $i from 0 through ($grid-columns - 1) {
      @if not($infix == '' and $i == 0) {
        .offset#{$infix}-#{$i} {
          @include make-col-offset($i, $grid-columns);
        }
      }
    }

    // Gutters
    @for $i from 0 through 5 {
      .g#{$infix}-#{$i},
      .gx#{$infix}-#{$i} {
        --bs-gutter-x: #{$i * 0.25rem} !important;
      }

      .g#{$infix}-#{$i},
      .gy#{$infix}-#{$i} {
        --bs-gutter-y: #{$i * 0.25rem} !important;
      }
    }
  }
}

// Row columns
@each $breakpoint in map-keys($grid-breakpoints) {
  $infix: if($breakpoint == xs, '', '-#{$breakpoint}');

  @include media-breakpoint-up($breakpoint, $grid-breakpoints) {
    @for $i from 1 through $grid-row-columns {
      .row-cols#{$infix}-#{$i} {
        > * {
          flex: 0 0 auto;
          width: percentage(calc(1 / $i));
        }
      }
    }

    .row-cols#{$infix}-auto {
      > * {
        flex: 0 0 auto;
        width: auto;
      }
    }
  }
}

// Order classes
@each $breakpoint in map-keys($grid-breakpoints) {
  $infix: if($breakpoint == xs, '', '-#{$breakpoint}');

  @include media-breakpoint-up($breakpoint, $grid-breakpoints) {
    .order#{$infix}-first {
      order: -1;
    }

    .order#{$infix}-0 {
      order: 0;
    }

    @for $i from 1 through 5 {
      .order#{$infix}-#{$i} {
        order: $i;
      }
    }

    .order#{$infix}-last {
      order: 6;
    }
  }
}

// Gap utilities that work with CSS Grid and Flexbox
.row {
  --bs-gutter-x: #{$grid-gutter-width};
  --bs-gutter-y: 0;
  margin-top: calc(-1 * var(--bs-gutter-y));
  margin-right: calc(-0.5 * var(--bs-gutter-x));
  margin-left: calc(-0.5 * var(--bs-gutter-x));

  > * {
    padding-right: calc(var(--bs-gutter-x) * 0.5);
    padding-left: calc(var(--bs-gutter-x) * 0.5);
    margin-top: var(--bs-gutter-y);
  }
}

// Additional gap utilities for grid and flex layouts
@for $i from 0 through 5 {
  .gap-#{$i} {
    gap: #{$i * 0.25rem} !important;
  }

  .gap-x-#{$i},
  .column-gap-#{$i} {
    column-gap: #{$i * 0.25rem} !important;
  }

  .gap-y-#{$i},
  .row-gap-#{$i} {
    row-gap: #{$i * 0.25rem} !important;
  }
}

// Display utilities for grid system
.d-none {
  display: none !important;
}

.d-inline {
  display: inline !important;
}

.d-inline-block {
  display: inline-block !important;
}

.d-block {
  display: block !important;
}

.d-grid {
  display: grid !important;
}

.d-table {
  display: table !important;
}

.d-table-row {
  display: table-row !important;
}

.d-table-cell {
  display: table-cell !important;
}

.d-flex {
  display: flex !important;
}

.d-inline-flex {
  display: inline-flex !important;
}

// Responsive display utilities
@each $breakpoint in map-keys($grid-breakpoints) {
  $infix: if($breakpoint == xs, '', '-#{$breakpoint}');

  @include media-breakpoint-up($breakpoint, $grid-breakpoints) {
    .d#{$infix}-none {
      display: none !important;
    }

    .d#{$infix}-inline {
      display: inline !important;
    }

    .d#{$infix}-inline-block {
      display: inline-block !important;
    }

    .d#{$infix}-block {
      display: block !important;
    }

    .d#{$infix}-grid {
      display: grid !important;
    }

    .d#{$infix}-table {
      display: table !important;
    }

    .d#{$infix}-table-row {
      display: table-row !important;
    }

    .d#{$infix}-table-cell {
      display: table-cell !important;
    }

    .d#{$infix}-flex {
      display: flex !important;
    }

    .d#{$infix}-inline-flex {
      display: inline-flex !important;
    }
  }
}

// Flexbox utilities
.flex-row {
  flex-direction: row !important;
}

.flex-column {
  flex-direction: column !important;
}

.flex-row-reverse {
  flex-direction: row-reverse !important;
}

.flex-column-reverse {
  flex-direction: column-reverse !important;
}

.flex-wrap {
  flex-wrap: wrap !important;
}

.flex-nowrap {
  flex-wrap: nowrap !important;
}

.flex-wrap-reverse {
  flex-wrap: wrap-reverse !important;
}

.justify-content-start {
  justify-content: flex-start !important;
}

.justify-content-end {
  justify-content: flex-end !important;
}

.justify-content-center {
  justify-content: center !important;
}

.justify-content-between {
  justify-content: space-between !important;
}

.justify-content-around {
  justify-content: space-around !important;
}

.justify-content-evenly {
  justify-content: space-evenly !important;
}

.align-items-start {
  align-items: flex-start !important;
}

.align-items-end {
  align-items: flex-end !important;
}

.align-items-center {
  align-items: center !important;
}

.align-items-baseline {
  align-items: baseline !important;
}

.align-items-stretch {
  align-items: stretch !important;
}

.align-content-start {
  align-content: flex-start !important;
}

.align-content-end {
  align-content: flex-end !important;
}

.align-content-center {
  align-content: center !important;
}

.align-content-between {
  align-content: space-between !important;
}

.align-content-around {
  align-content: space-around !important;
}

.align-content-stretch {
  align-content: stretch !important;
}

.align-self-auto {
  align-self: auto !important;
}

.align-self-start {
  align-self: flex-start !important;
}

.align-self-end {
  align-self: flex-end !important;
}

.align-self-center {
  align-self: center !important;
}

.align-self-baseline {
  align-self: baseline !important;
}

.align-self-stretch {
  align-self: stretch !important;
}

// Responsive flexbox utilities
@each $breakpoint in map-keys($grid-breakpoints) {
  $infix: if($breakpoint == xs, '', '-#{$breakpoint}');

  @include media-breakpoint-up($breakpoint, $grid-breakpoints) {
    .flex#{$infix}-row {
      flex-direction: row !important;
    }

    .flex#{$infix}-column {
      flex-direction: column !important;
    }

    .flex#{$infix}-row-reverse {
      flex-direction: row-reverse !important;
    }

    .flex#{$infix}-column-reverse {
      flex-direction: column-reverse !important;
    }

    .flex#{$infix}-wrap {
      flex-wrap: wrap !important;
    }

    .flex#{$infix}-nowrap {
      flex-wrap: nowrap !important;
    }

    .flex#{$infix}-wrap-reverse {
      flex-wrap: wrap-reverse !important;
    }

    .justify-content#{$infix}-start {
      justify-content: flex-start !important;
    }

    .justify-content#{$infix}-end {
      justify-content: flex-end !important;
    }

    .justify-content#{$infix}-center {
      justify-content: center !important;
    }

    .justify-content#{$infix}-between {
      justify-content: space-between !important;
    }

    .justify-content#{$infix}-around {
      justify-content: space-around !important;
    }

    .justify-content#{$infix}-evenly {
      justify-content: space-evenly !important;
    }

    .align-items#{$infix}-start {
      align-items: flex-start !important;
    }

    .align-items#{$infix}-end {
      align-items: flex-end !important;
    }

    .align-items#{$infix}-center {
      align-items: center !important;
    }

    .align-items#{$infix}-baseline {
      align-items: baseline !important;
    }

    .align-items#{$infix}-stretch {
      align-items: stretch !important;
    }

    .align-content#{$infix}-start {
      align-content: flex-start !important;
    }

    .align-content#{$infix}-end {
      align-content: flex-end !important;
    }

    .align-content#{$infix}-center {
      align-content: center !important;
    }

    .align-content#{$infix}-between {
      align-content: space-between !important;
    }

    .align-content#{$infix}-around {
      align-content: space-around !important;
    }

    .align-content#{$infix}-stretch {
      align-content: stretch !important;
    }

    .align-self#{$infix}-auto {
      align-self: auto !important;
    }

    .align-self#{$infix}-start {
      align-self: flex-start !important;
    }

    .align-self#{$infix}-end {
      align-self: flex-end !important;
    }

    .align-self#{$infix}-center {
      align-self: center !important;
    }

    .align-self#{$infix}-baseline {
      align-self: baseline !important;
    }

    .align-self#{$infix}-stretch {
      align-self: stretch !important;
    }
  }
}