body {
  padding-top: 0px;
  padding-bottom: 0px;
}

.hide {
  display: none !important;
}

#overlay {
  position: fixed;
  display: none !important;
  width: 100%;
  height: 100%;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  /* Black background with opacity */
  background-color: rgba(0, 0, 0, 0.5);
  z-index: 9999;
  /* Add a pointer on hover */
  cursor: pointer;
}

#overlay.show, #overlay.htmx-request {
  display: flex !important;
}

#loading-animation {
  width: 50px;
  height: 50px;
  margin: auto;
  color: white;
}

.form-signin {
  max-width: 530px;
  padding: 15px;
  margin: 0 auto;
}

.form-signin .form-control {
  position: relative;
  height: auto;
  -webkit-box-sizing: border-box;
  -moz-box-sizing: border-box;
  box-sizing: border-box;
  padding: 10px;
  font-size: 16px;
}

.form-signin .form-control:focus {
  z-index: 2;
}

.form-signin input {
  border-bottom-right-radius: 0;
  border-bottom-left-radius: 0;
}

.form-signin button {
  margin-top: 10px;
  margin-bottom: 10px;
}

.has-error {
  color: red;
}

.input-label {
  display: flex;
  flex-direction: row;
}

/* Firefox */
input[type="number"] {
  -moz-appearance: textfield;
}

input[type="number"]::-webkit-inner-spin-button,
input[type="number"]::-webkit-outer-spin-button {
  -webkit-appearance: none;
  -moz-appearance: none;
  appearance: none;
  margin: 0;
}

.table-responsive {
  flex-grow: 1;
  margin-inline: auto;
}

/*
 * Listentabelle in einer Karte.
 *
 * `main` ist eine Flex-Spalte über die Fensterhöhe, `.table-responsive` als direktes
 * Flex-Kind damit höhenbegrenzt — und genau diese Höhe misst, wer die Zeilenzahl bestimmt
 * (`pageHeightRows.js` hier, das `pageResize`-Plugin auf den übrigen Listenseiten). Eine Karte
 * dazwischen muss die Begrenzung deshalb weiterreichen, sonst wird ohne Grenze gerechnet und die
 * ganze Tabelle landet auf einer Seite.
 */
.table-card {
  flex: 1 1 auto;
  min-height: 0;
}

/*
 * Die Karte hat mehrere Abschnitte: Titel, bei Bedarf Filter, und die Tabelle — jeder ein eigener
 * `card-body`, getrennt durch eine Linie in der Rahmenfarbe der Karte. Nur der Tabellenabschnitt
 * wächst; Titel und Filter behalten ihre Höhe, sonst gäben sie der Tabelle Platz ab.
 */
.table-card > .card-body {
  flex: 0 0 auto;
}

.table-card > .card-body + .card-body {
  border-top: 1px solid rgba(0, 0, 0, .125);
}

/* Der Tabellenabschnitt reicht die Höhenbegrenzung an `.table-responsive` weiter — siehe oben. */
.table-card > .card-body.table-section {
  display: flex;
  flex-direction: column;
  flex: 1 1 auto;
  min-height: 0;
}

.table-card > .card-body.table-section > .table-responsive {
  min-height: 0;
}

/* Das Padding des Titelabschnitts kommt vom `card-body`, nicht zusätzlich vom Header. */
.table-card > .card-body > .header {
  padding-top: 0;
}

/*
 * Filter in ihrem eigenen Kartenabschnitt — bei den vier Produkte-Seiten nur `/product/dormant`,
 * wo vier Filter nicht mehr neben den Titel passen. Die Basisregel `.filter > * { margin: auto }`
 * verteilt die Gruppen über die ganze Breite; hier sollen sie links stehen und gleichmäßige
 * Abstände haben. Filter im `.header` der anderen Seiten trifft der Selektor nicht.
 */
.table-card > .card-body > .filter {
  align-items: center;
  column-gap: 2rem;
  row-gap: .75rem;
}

.table-card > .card-body > .filter > * {
  margin: 0;
}

/* `input-group` ist von Bootstrap `width: 100%` und zieht das Feld auf Spaltenbreite. */
.table-card > .card-body > .filter .input-group {
  align-items: center;
  flex-wrap: nowrap;
  width: auto;
}

/* „0,0“ und „4“ brauchen keine 200 px — wie `input.date` weiter unten. */
.table-card > .card-body > .filter .input-group > input[type="number"] {
  flex: 0 0 auto;
  width: 5rem;
}

/* Die Schalter zusammenhalten und vom Zahlenteil abgrenzen. */
.table-card > .card-body > .filter .custom-switch {
  white-space: nowrap;
}



/*
 * Luft zwischen Suche und Tabelle, wie im DataTables-Beispiel für Bootstrap 4. Dessen
 * `div.dt-container > div.row { margin-bottom: .5rem }` greift bei uns nicht, weil die Tabelle in
 * einem `.table-responsive` steckt: dafür setzt DataTables die Layout-Zeilen mit
 * `div.table-responsive > div.dt-container > div.row { margin: 0 }` zurück, sonst lösten die
 * negativen Seitenabstände von `.row` im `overflow-x: auto` einen waagerechten Scroll aus.
 * Hier kommt nur die Unterkante zurück, die Seiten bleiben bei 0 — und die letzte Zeile
 * (Info und Blättern) bleibt ohne, wie im Beispiel.
 */
div.table-responsive > div.dt-container > div.row:not(:last-child) {
  margin-bottom: .5rem;
}

/*
 * Zeile aufklappen und die ausgeblendeten Spalten zeigen (`columnVisibility.js`). Geklickt wird
 * die Zelle ganz links; das Chevron davor kommt aus Font Awesome, damit die Spalte kein weiteres
 * Element braucht. Die Klasse `dt-expand` setzt das Skript nur, solange etwas ausgeblendet ist,
 * `dt-hasChild` setzt DataTables an der aufgeklappten Zeile.
 */
td.dt-expand {
  cursor: pointer;
}

td.dt-expand::before {
  font: normal normal normal 14px/1 FontAwesome;
  content: "\f078";
  margin-inline-end: .4rem;
  color: var(--main-button-color);
}

tr.dt-hasChild > td.dt-expand::before {
  content: "\f077";
}

/*
 * Stift vor den editierbaren Zahlen der Preiskalkulation, damit man sieht, dass die Zelle
 * bearbeitet werden kann. Als `::before` und nicht als Element im Inhalt: `endPriceEdit` in der
 * `priceCalculation.js` liest den Wert aus `textContent`, und darin tauchen Pseudo-Elemente nicht
 * auf — ein echtes `<i>` müsste beim Lesen und Schreiben jedes Mal umgangen werden.
 */
td.editablePrice {
  cursor: pointer;
}

td.editablePrice::before {
  font: normal normal normal 14px/1 FontAwesome;
  content: "\f040";
  margin-inline-end: .4rem;
  color: var(--main-button-color);
}

/*
 * Zellen und Spaltenköpfe einzeilig und abgeschnitten.
 *
 * Damit sind alle Zeilen gleich hoch — das braucht die Rechnung in der `pageHeightRows.js`, die
 * sonst mit 88 bis 151 px hohen Zeilen umgehen muss und dann eine Zeilenhöhe frei lässt. Der volle
 * Text steht in der aufgeklappten Zeile (`columnVisibility.js`).
 *
 * `max-width` ist nötig, nicht Geschmack: `text-overflow: ellipsis` greift in einer Tabellenzelle
 * nur, wenn ihre Breite begrenzt ist — mit `table-layout: auto` wächst die Zelle sonst einfach mit.
 * Die Aktionsspalte bleibt außen vor, `overflow: hidden` würde dort die Knöpfe beschneiden.
 */
.table-card table.dataTable > thead > tr > th,
.table-card table.dataTable > tbody > tr > td:not(.sticky) {
  max-width: 14rem;
  overflow: hidden;
  white-space: nowrap;
  text-overflow: ellipsis;
}

/* Die aufgeklappte Zeile ist die Stelle mit dem Volltext, hier wird umgebrochen. */
.table-card table.dataTable > tbody > tr.dt-row-details-row > td {
  white-space: normal;
}

dl.dt-row-details {
  display: grid;
  grid-template-columns: auto 1fr;
  gap: .25rem .75rem;
  padding: .5rem;
  margin-bottom: 0;
  white-space: normal;

  > dt {
    font-weight: 600;
  }

  > dd {
    margin-bottom: 0;
  }
}

td.sticky {
  position: sticky !important;
  right: 0 !important;
  /*
   * Deckend, sonst scrollen die Zellen darunter durch. Vorher stand hier `inherit` — das kam aus
   * DataTables 1.x, wo die Zeilen noch `odd`/`even` trugen und eine `.odd`-Regel ihnen einen
   * Hintergrund gab. Seit 2.x setzt die Bootstrap-Integration die Zeilen auf `transparent`,
   * damit war auch diese Spalte durchsichtig. Streifen und Hover legt DataTables als `box-shadow`
   * über jede Zelle, die Aktionsspalte färbt sich also von selbst mit.
   */
  background-color: #fff;
  z-index: 2;

  div {
    display: flex;
    flex-flow: row-reverse nowrap;
    gap: .25rem;
  }
}

.hidden-text {
  color: white;
}

.header {
  display: flex;
  padding-top: 1rem;
  align-items: center;
  justify-content: space-between;
  flex-wrap: wrap;
}

.header > * {
  margin: 0.5rem;
}

.header > h1 {
  flex-grow: 1;
  word-break: break-word;
}

.actions {
  display: flex;
  flex-flow: row wrap;
  gap: .5rem;
  margin-inline: auto 0;

  > * {
    width: fit-content;
    margin: auto;
  }
}

.filter {
  display: flex;
  flex-flow: row wrap;
  gap: .5rem;

  > * {
    width: fit-content;
    margin: auto;
  }

  > * + *::before {
    border-left: dotted 1px silver;
  }

  .input-group > label {
    padding-inline-end: 0.5rem;
  }

}

.deactivated {
  color: red;
}

.hint {
  margin-inline-start: 2px;
}

.data-nature-icon {
  background: url('/image/dataNature-15abf9970403f685e1cebdfecb3a9770.svg');
  background-repeat: no-repeat;
  background-size: cover;
  display: inline-block;
  height: 16px;
  width: 16px;
}

.bnn-icon {
  background: url('/image/bnn-73ee83604cefc7cffa4211dc81c65ac7.png');
  background-repeat: no-repeat;
  background-size: cover;
  display: inline-block;
  height: 16px;
  width: 16px;
}

.statusBadge {
  position: absolute;
  bottom: 15px;
  right: 15px;
  left: 15px;
  font-size: x-large;
}

.modal { 
  overflow: auto !important; 
}

.modal-actions {
  flex-grow: 1;
  font-size: large;
  text-align: right;
}

input.date {
  width: 80px;
}

/*
 * Die Marge in der Preiskalkulation färbt die ganze Zelle (`bg-success`/`bg-warning`/`bg-danger`/
 * `bg-secondary` kommen aus der `priceCalculation.js` über `createdCell`). Die Schrift muss hier
 * weiß gesetzt werden — die Hintergrund-Klassen von Bootstrap bringen keine Textfarbe mit.
 * `td` mitnennen, damit die Regel gegen die Tabellenfarbe gewinnt.
 */
td.marginCell {
  color: #fff;
}

.avatar {
  width: 100%;
  img {
    max-width: 300px;
  }
}

.kpi {
  min-width: 150px;
  hyphens: auto;
  padding: 0rem;
  .card-body {
    padding: 1rem;
    display: flex;
    flex-direction: column;
    .card-title {
      flex-grow: 1;
    }
  }
}

.icon-wrapper {
  position: relative;
  display: inline-block;
}

.fa-indicator {
  position: absolute;
  top: -4px;
  right: -8px;
  font-size: 0.65em;
  line-height: 1;
}

/*
 * Mobil (unter Bootstraps `md`, wo auch DataTables seine Kopfzeile stapelt).
 *
 * Auf dem Telefon ist die Breite und nicht die Höhe knapp, deshalb hier nur die Anordnung:
 * alles linksbündig statt mittig, kleinere Überschrift, die Bedienelemente paarweise auf einer
 * Zeile — und die Aktionsspalte klebt nicht mehr.
 */
@media screen and (max-width: 767px) {
  /* Die Kopfzeile stapelt; ohne das zentriert `margin: auto` jedes Element einzeln. */
  .header {
    justify-content: flex-start;
  }

  .header > *,
  .filter > *,
  .actions,
  .actions > * {
    margin-inline: 0;
  }

  .header > h1 {
    font-size: 1.75rem;
  }

  /*
   * DataTables macht seine Layout-Zellen unter `md` zu Blöcken, dann steht jedes Bedienelement auf
   * einer eigenen Zeile. Paarweise nebeneinander ist es kompakter und ordentlicher: links die
   * Zeilenzahl mit ihrem Knopf, rechts die Suche mit dem Spalten-Icon.
   */
  div.dt-container div.dt-layout-start,
  div.dt-container div.dt-layout-end {
    display: flex;
    align-items: center;
    gap: .5rem;
    /* ohne das schrumpfen die Zellen nicht: ein Suchfeld bringt rund 170 px Mindestbreite mit,
       und die Infozeile ist breiter als der Platz — beides sprengte sonst die Zeile */
    min-width: 0;
  }

  div.dt-container div.dt-layout-end > *:not(:first-child) {
    margin-left: 0;
  }

  /* Das Suchfeld nimmt den Rest der Zeile, das Icon bleibt daneben. */
  div.dt-container div.dt-search {
    flex: 1 1 auto;
    min-width: 0;
  }

  div.dt-container div.dt-search input {
    width: 100%;
  }


  /*
   * Platz für Datenzeilen schaffen: gemessen gingen bei 375 px 321 von 454 px für Bedienelemente,
   * Spaltenkopf, Infozeile und Blätterleiste weg — es blieb genau eine Zeile übrig. Die folgenden
   * drei Regeln holen je rund 40 px zurück, also drei Zeilen.
   */

  /* Die vier Bedienelemente auf eine Zeile statt auf zwei. Nur oben: unten sollen Infozeile und
     Blätterleiste untereinander bleiben. */
  div.dt-container > div.row:first-child > div.dt-layout-start,
  div.dt-container > div.row:first-child > div.dt-layout-end {
    width: auto;
    max-width: none;
  }

  /* „Zeilen“ ist hier verzichtbar — die Auswahl selbst sagt schon „(Seitenhöhe)“. */
  div.dt-container div.dt-length label {
    display: none;
  }

  /*
   * Filter im eigenen Kartenabschnitt stapeln hier. Ohne Raster beginnt jedes Feld hinter seinem
   * Label, und die Felder stehen versetzt — bei „Bestand bis“ und „Nicht verkauft seit (Wochen)“
   * sind das über 100 px Unterschied. Zwei Spalten richten die Label links und die Felder
   * untereinander aus; `display: contents` löst die Eingabegruppe auf, damit Label und Feld
   * selbst zu Rasterfeldern werden.
   */
  .table-card > .card-body > .filter {
    display: grid;
    grid-template-columns: auto 5rem;
    justify-content: start;
    column-gap: .75rem;
  }

  .table-card > .card-body > .filter .input-group {
    display: contents;
  }

  /* Die Schalter haben kein Feld, sie nehmen beide Spalten. */
  .table-card > .card-body > .filter .custom-switch {
    grid-column: 1 / -1;
  }

  /* „Erste“ und „Letzte“ weg, sonst bricht die Blätterleiste auf zwei Zeilen um. Es sind das
     erste und letzte `li`, weil DataTables hier mit `full_numbers` blättert. */
  div.dt-container div.dt-paging ul.pagination > li:first-child,
  div.dt-container div.dt-paging ul.pagination > li:last-child {
    display: none;
  }
}