import * as List from "./list.js";
import * as Curry from "./curry.js";
import * as Caml_bytes from "./caml_bytes.js";
import * as Caml_option from "./caml_option.js";
import * as Caml_string from "./caml_string.js";
import * as Caml_exceptions from "./caml_exceptions.js";
import * as CamlinternalLazy from "./camlinternalLazy.js";

var Failure = /* @__PURE__ */Caml_exceptions.create("Stream.Failure");

var $$Error = /* @__PURE__ */Caml_exceptions.create("Stream.Error");

function count(param) {
  if (param !== undefined) {
    return param.count;
  } else {
    return 0;
  }
}

function data(param) {
  if (param !== undefined) {
    return param.data;
  } else {
    return /* Sempty */0;
  }
}

function get_data(count, _d) {
  while(true) {
    var d = _d;
    if (typeof d === "number") {
      return d;
    }
    switch (d.TAG | 0) {
      case /* Scons */0 :
          return d;
      case /* Sapp */1 :
          var d2 = d._1;
          var match = get_data(count, d._0);
          if (typeof match === "number") {
            _d = d2;
            continue ;
          }
          if (match.TAG === /* Scons */0) {
            return {
                    TAG: /* Scons */0,
                    _0: match._0,
                    _1: {
                      TAG: /* Sapp */1,
                      _0: match._1,
                      _1: d2
                    }
                  };
          }
          throw {
                RE_EXN_ID: "Assert_failure",
                _1: [
                  "stream.ml",
                  48,
                  12
                ],
                Error: new Error()
              };
      case /* Slazy */2 :
          _d = CamlinternalLazy.force(d._0);
          continue ;
      case /* Sgen */3 :
          var g = d._0;
          var match$1 = g.curr;
          if (match$1 !== undefined) {
            var a = Caml_option.valFromOption(match$1);
            if (a !== undefined) {
              g.curr = undefined;
              return {
                      TAG: /* Scons */0,
                      _0: Caml_option.valFromOption(a),
                      _1: d
                    };
            } else {
              return /* Sempty */0;
            }
          }
          var a$1 = Curry._1(g.func, count);
          if (a$1 !== undefined) {
            return {
                    TAG: /* Scons */0,
                    _0: Caml_option.valFromOption(a$1),
                    _1: d
                  };
          } else {
            g.curr = Caml_option.some(undefined);
            return /* Sempty */0;
          }
      
    }
  };
}

function peek_data(s) {
  while(true) {
    var f = s.data;
    if (typeof f === "number") {
      return ;
    }
    switch (f.TAG | 0) {
      case /* Scons */0 :
          return Caml_option.some(f._0);
      case /* Sapp */1 :
          var d = get_data(s.count, s.data);
          if (typeof d === "number") {
            return ;
          }
          if (d.TAG === /* Scons */0) {
            s.data = d;
            return Caml_option.some(d._0);
          }
          throw {
                RE_EXN_ID: "Assert_failure",
                _1: [
                  "stream.ml",
                  71,
                  12
                ],
                Error: new Error()
              };
      case /* Slazy */2 :
          s.data = CamlinternalLazy.force(f._0);
          continue ;
      case /* Sgen */3 :
          var g = f._0;
          var a = g.curr;
          if (a !== undefined) {
            return Caml_option.valFromOption(a);
          }
          var x = Curry._1(g.func, s.count);
          g.curr = Caml_option.some(x);
          return x;
      
    }
  };
}

function peek(s) {
  if (s !== undefined) {
    return peek_data(s);
  }
  
}

function junk_data(s) {
  while(true) {
    var g = s.data;
    if (typeof g !== "number") {
      switch (g.TAG | 0) {
        case /* Scons */0 :
            s.count = s.count + 1 | 0;
            s.data = g._1;
            return ;
        case /* Sgen */3 :
            var g$1 = g._0;
            var match = g$1.curr;
            if (match !== undefined) {
              s.count = s.count + 1 | 0;
              g$1.curr = undefined;
              return ;
            }
            break;
        default:
          
      }
    }
    var match$1 = peek_data(s);
    if (match$1 === undefined) {
      return ;
    }
    continue ;
  };
}

function junk(data) {
  if (data !== undefined) {
    return junk_data(data);
  }
  
}

function nget_data(n, s) {
  if (n <= 0) {
    return [
            /* [] */0,
            s.data,
            0
          ];
  }
  var a = peek_data(s);
  if (a === undefined) {
    return [
            /* [] */0,
            s.data,
            0
          ];
  }
  var a$1 = Caml_option.valFromOption(a);
  junk_data(s);
  var match = nget_data(n - 1 | 0, s);
  return [
          {
            hd: a$1,
            tl: match[0]
          },
          {
            TAG: /* Scons */0,
            _0: a$1,
            _1: match[1]
          },
          match[2] + 1 | 0
        ];
}

function npeek(n, d) {
  if (d !== undefined) {
    var match = nget_data(n, d);
    d.count = d.count - match[2] | 0;
    d.data = match[1];
    return match[0];
  } else {
    return /* [] */0;
  }
}

function next(s) {
  var a = peek(s);
  if (a !== undefined) {
    junk(s);
    return Caml_option.valFromOption(a);
  }
  throw {
        RE_EXN_ID: Failure,
        Error: new Error()
      };
}

function empty(s) {
  var match = peek(s);
  if (match === undefined) {
    return ;
  }
  throw {
        RE_EXN_ID: Failure,
        Error: new Error()
      };
}

function iter(f, strm) {
  var _param;
  while(true) {
    var a = peek(strm);
    if (a === undefined) {
      return ;
    }
    junk(strm);
    Curry._1(f, Caml_option.valFromOption(a));
    _param = undefined;
    continue ;
  };
}

function from(f) {
  return {
          count: 0,
          data: {
            TAG: /* Sgen */3,
            _0: {
              curr: undefined,
              func: f
            }
          }
        };
}

function of_list(l) {
  return {
          count: 0,
          data: List.fold_right((function (x, l) {
                  return {
                          TAG: /* Scons */0,
                          _0: x,
                          _1: l
                        };
                }), l, /* Sempty */0)
        };
}

function of_string(s) {
  var count = {
    contents: 0
  };
  return from(function (param) {
              var c = count.contents;
              if (c < s.length) {
                count.contents = count.contents + 1 | 0;
                return Caml_string.get(s, c);
              }
              
            });
}

function of_bytes(s) {
  var count = {
    contents: 0
  };
  return from(function (param) {
              var c = count.contents;
              if (c < s.length) {
                count.contents = count.contents + 1 | 0;
                return Caml_bytes.get(s, c);
              }
              
            });
}

function iapp(i, s) {
  return {
          count: 0,
          data: {
            TAG: /* Sapp */1,
            _0: data(i),
            _1: data(s)
          }
        };
}

function icons(i, s) {
  return {
          count: 0,
          data: {
            TAG: /* Scons */0,
            _0: i,
            _1: data(s)
          }
        };
}

function ising(i) {
  return {
          count: 0,
          data: {
            TAG: /* Scons */0,
            _0: i,
            _1: /* Sempty */0
          }
        };
}

function lapp(f, s) {
  return {
          count: 0,
          data: {
            TAG: /* Slazy */2,
            _0: {
              LAZY_DONE: false,
              VAL: (function () {
                  return {
                          TAG: /* Sapp */1,
                          _0: data(Curry._1(f, undefined)),
                          _1: data(s)
                        };
                })
            }
          }
        };
}

function lcons(f, s) {
  return {
          count: 0,
          data: {
            TAG: /* Slazy */2,
            _0: {
              LAZY_DONE: false,
              VAL: (function () {
                  return {
                          TAG: /* Scons */0,
                          _0: Curry._1(f, undefined),
                          _1: data(s)
                        };
                })
            }
          }
        };
}

function lsing(f) {
  return {
          count: 0,
          data: {
            TAG: /* Slazy */2,
            _0: {
              LAZY_DONE: false,
              VAL: (function () {
                  return {
                          TAG: /* Scons */0,
                          _0: Curry._1(f, undefined),
                          _1: /* Sempty */0
                        };
                })
            }
          }
        };
}

function slazy(f) {
  return {
          count: 0,
          data: {
            TAG: /* Slazy */2,
            _0: {
              LAZY_DONE: false,
              VAL: (function () {
                  return data(Curry._1(f, undefined));
                })
            }
          }
        };
}

function dump_data(f, param) {
  if (typeof param === "number") {
    console.log("Sempty");
    return ;
  }
  switch (param.TAG | 0) {
    case /* Scons */0 :
        console.log("Scons (");
        Curry._1(f, param._0);
        console.log(", ");
        dump_data(f, param._1);
        console.log(")");
        return ;
    case /* Sapp */1 :
        console.log("Sapp (");
        dump_data(f, param._0);
        console.log(", ");
        dump_data(f, param._1);
        console.log(")");
        return ;
    case /* Slazy */2 :
        console.log("Slazy");
        return ;
    case /* Sgen */3 :
        console.log("Sgen");
        return ;
    
  }
}

function dump(f, s) {
  console.log("{count = ");
  var i = count(s);
  console.log(String(i));
  console.log("; data = ");
  dump_data(f, data(s));
  console.log("}");
  console.log("");
}

var sempty;

export {
  Failure ,
  $$Error ,
  from ,
  of_list ,
  of_string ,
  of_bytes ,
  iter ,
  next ,
  empty ,
  peek ,
  junk ,
  count ,
  npeek ,
  iapp ,
  icons ,
  ising ,
  lapp ,
  lcons ,
  lsing ,
  sempty ,
  slazy ,
  dump ,
}
/* No side effect */