/**
 * Destroy / delete all sessions of the given auth Id
 */
function destroyAllOfAuthIdImpl(storage: RedisStorage, authId: AuthId): T.Task<void> {
  const redis = storage.redis;
  return T.node(redis, storage.authKey(authId), redis.smembers)
    .map((refs: string[]) => {
      redis.del([authId].concat(refs) as any);
    });
}

 it('200 and etag when no etag query parameters', async () => {
   const stat = await T.toPromise(T.node(null, path.join(__dirname, 'fixture', 'attic', 'a'), fs.stat));
   const extag = await T.toPromise(defaultEtag(stat, true));
   const req = new IncomingMessageMock({ url: '/attic/a' });
   await T.toPromise(request(staticTest, req).map(resp => {
     assert.equal(resp.status, 200);
     assert.equal(resp.headers['ETag'], (extag as any).value);
   }));
 });

  it('can move file upload to target dir', async function () {
    const middleware = mutter({ getStorage });
    const form = new FormData();

    form.append('name', 'thatiq');
    form.append('tiny0', file('tiny0.json'));

    const { state } = await T.toPromise(submitForm(middleware, form));
    const dest = await T.toPromise(T.node(null, temp.mkdir));
    const files: Files = state.files;
    const target = path.join(dest, 'tiny-uploaded.json');
    await T.toPromise(files['tiny0'][0].move(target));
    const [targetStat, sourceStat] = await T.toPromise(T.bothPar(
      T.node(null, target, fs.stat),
      T.node(null, path.join(__dirname, 'fixtures', 'tiny0.json'), fs.stat)
    ));
    assert.equal(targetStat.size, sourceStat.size);
    await T.toPromise(T.node(null, dest, rimraf));
  });

export function getFileInfo(path: string): T.Task<FileInfo> {
  return T.node(null, path, FS.stat)
    .chain(stat => {
      if (stat.isFile()) {
        let time = H.fromDate(stat.mtime);
        let date = H.formatHttpDate(time);
        return T.pure(new FileInfo(path, stat.size, time, date));
      }
      return T.raise(new Error(`getInfo: ${path}  isn't a file`));
    });
}

function listenConnection(
  state: ServerState,
  sett: Z.Settings
): T.Task<void> {
  const listenOpts = sett.listenOpts;
  const server = state.server as Server | HServer;
  if (listenOpts.path) {
    return bindConnectionUnix(listenOpts.path, listenOpts.permission || '660', listenOpts, server);
  }
  return T.node(server, listenOpts, server.listen);
}

 T.supervise(T.co(function* () {
   let fdRef: R.Ref<number> = yield R.newRef(-1);
   yield withFdCache(3000, getFd =>
     getFd(0)(path.join(__dirname, '..', 'package.json')).chain(fd =>
       R.writeRef(fdRef, (fd[0] as any).value))
   );
   let fd: number = yield R.readRef(fdRef);
   return T.attempt(T.node(null, fd, fs.readFile)).chain(mcont => {
     assert.ok(isLeft(mcont));
     return T.pure(void 0);
   });
 }))

function bindConnectionUnix(
  path: string,
  permission: number | string,
  listenOpts: Z.ListenOpts,
  server: Server | HServer
): T.Task<void> {
  return T.apathize(T.node(null, path, FS.unlink))
    .chain(() =>
      T.node(server, listenOpts, server.listen)
    ).chain(() =>
      T.forkTask(T.node(null, path, permission, FS.chmod))
    ) as T.Task<any>;
}

export function fileSystemLookup(
  etagFn: EtagLookup,
  prefix: string,
  pieces: Piece[],
  weakEtags: boolean
): T.Task<LookupResult> {
  const fp = pathFromPieces(prefix, pieces);
  return T.attempt(T.node(null, fp, fs.stat))
    .chain(estat => {
      if (isLeft(estat))
        return T.pure({ tag: LookupResultType.LRNOTFOUND } as LookupResult);

      const { value: stat } = estat;
      if (stat.isFile()) {
        return T.pure(mkLookupResult(LookupResultType.LRFILE, mkFile(
          stat.size,
          (s, h) => W.responseFile(s, h, fp),
          pieces.length === 0 ? '' : pieces[pieces.length - 1],
          etagFn(stat, weakEtags),
          just(stat.mtime)
        )));
      }

      return T.node(null, fp, fs.readdir)
        .chain(entries_ => {
          const entries = entries_.filter(isVisible);
          return T.forIn(entries, frel => {
            const fpAbs = path.join(fp, frel);
            return T.attempt(T.node(null, fpAbs, fs.stat))
              .map(estate => {
                if (isLeft(estate)) {
                  return nothing as Maybe<Either<string, File>>;
                }
                const stat = estate.value;
                if (stat.isDirectory()) {
                  return just(left(frel)) as Maybe<Either<string, File>>;
                }

                // file
                return just(right(mkFile(
                  stat.size,
                  (s, h) => W.responseFile(s, h, fpAbs),
                  frel,
                  etagFn(stat, weakEtags),
                  just(stat.mtime)
                ))) as Maybe<Either<string, File>>;
              });
          }).map(xs => mkLookupResult(LookupResultType.LRFOLDER, catMaybes(xs)));
        });
    });
}