import type { Items, Item, Tree } from "./type";

import type { Items, Item, Tree } from './type'

export const PIJUL_DIR = ".pijul";

export const PIJUL_DIR = '.pijul'

  const splitted = name.split(".");

  const splitted = name.split('.')

    return null;

    return null

    return splitted.at(-1) ?? null;

    return splitted.at(-1) ?? null

export function getParent(path: string): string {
  return path.split('/').at(-1) as string
}

      );

      )

export const toItems = async (path = "repo", depth = 1): Promise<Items> => {
  const tree: Items = [];

export const toItems = async (path = 'repo', depth = 1): Promise<Items> => {
  const tree: Items = []

    const entries = await readdir(path, { withFileTypes: true });

    const entries = await readdir(path, { withFileTypes: true })

        };
        tree.push({ ...item, id: tree.length + 1 });

        }
        tree.push({ ...item, id: tree.length + 1 })

          await fileCollector(tree, join(path, dirent.name), depth + 1);

          await fileCollector(tree, join(path, dirent.name), depth + 1)

      });
  };

      })
  }

    await Promise.all(await fileCollector(tree, path, depth));

    await Promise.all(await fileCollector(tree, path, depth))

    console.error(error);

    console.error(error)

    return tree;

    return tree

};

}

      }));

      }))

    name: "root",

    name: 'root',

  };
};

  }
}

    return ""

    return ''

    return ""

    return ''

import { join } from 'node:path'
import { readdirSync, Dirent } from 'node:fs'
export type Ressource = {
  id: number
  name: string
  path: string
  depth: number
  isDir: boolean
  isVisible?: boolean
  extension?: string
  isOpen?: boolean // Only valide for folder;
  childrenIds?: number[]
}
export type Ressources = Ressource[]
export type ConfigT = {
  indent: number
  defaultDepth: number
  defaultRes: Ressource
}
export type StateT = {
  config: ConfigT
  ressources: Ressources
}
export const PIJUL_DIR = '.pijul'
export function getExtension(name: string): string {
  const splitted = name.split('.')
  return splitted.at(-1)!
}
export function getParent(path: string): string {
  return path.split('/').at(-1) as string
}
export const cmpDirent = (a: Dirent, b: Dirent): 0 | 1 | -1 =>
  !a.isDirectory() && b.isDirectory()
    ? -1
    : a.isDirectory() && !b.isDirectory()
    ? 1
    : 0
export const cmpRessources = (a: Ressource, b: Ressource): 0 | 1 | -1 =>
  a.depth > b.depth
    ? 1
    : a.depth < b.depth
    ? -1
    : a.isDir && !b.isDir
    ? -1
    : !a.isDir && b.isDir
    ? 1
    : ((s1: string, s2: string) => (s1 === s2 ? 0 : s1 > s2 ? 1 : -1))(
        a.name,
        b.name
      )
export function getRessources(path = 'repo') {
  const ressources: Ressources = []
  const collectRessources = (path: string, depth = 1, len = 0) => {
    const children = readdirSync(path, { withFileTypes: true })
      .filter((dirent) => dirent.name !== PIJUL_DIR)
      .sort(cmpDirent)
      .map((dirent, index) => {
        return {
          id: len === 0 ? index + 1 : len + index,
          ...(dirent.isDirectory()
            ? { extension: getExtension(dirent.name) }
            : null),
          name: dirent.name,
          path: join(path, dirent.name),
          depth,
          isDir: dirent.isDirectory(),
        }
      })
    if (len !== 0) {
      const childrenIds = children.map((ressource) => ressource.id)
      ressources.forEach((ressource, index, ressources) => {
        if (ressource.isDir && ressource.path === path) {
          ressources[index] = {
            ...ressource,
            childrenIds,
          }
        }
      })
    }
    ressources.push(...children)
    children.forEach((ressource) => {
      if (ressource.isDir) {
        collectRessources(ressource.path, depth + 1, ressources.length)
      }
    })
  }
  collectRessources(path)
  return ressources
}
export const transformRessources = (ressources: Ressources): Ressources =>
  ressources.sort(cmpRessources).map((ressource) => ({
    ...ressource,
    ...(ressource.depth > 1 ? { isVisible: false } : { isVisible: true }),
    ...(ressource.depth > 1 ? { isOpen: false } : { isVisible: true }),
  }))

import Fastify from "fastify";
import cors from "@fastify/cors";

import Fastify from 'fastify'
import cors from '@fastify/cors'

import process from "node:process";
import path from "node:path";

import process from 'node:process'

import Repository from "./repository";
import { toItems, toTree, cmpItems, getContent } from "../src/tree";
// import { request } from "node:http";

import { getRessources, transformRessources } from '../src/ressources'
import { getContent } from '../src/tree'

});

})

    };

    }

      corsOptions.origin = false;

      corsOptions.origin = false

    callback(null, corsOptions);
  };
});
fastify.get("/readme", async (_request, reply) => {
  const rootPath = path.join(process.cwd(), "repo");
  const repo = new Repository(rootPath);

    callback(null, corsOptions)
  }
})

  const fileName = "readme.md";
  const status = await repo.isFile(fileName);

fastify.get('/api/ressources', async (_request, reply) => {
  const rawRessources = getRessources()
  const ressources = transformRessources(rawRessources)

  reply.send({ info: status });
});

  reply.send({ ressources })
})

fastify.get("/info", async (_request, reply) => {
  const rootPath = path.join(process.cwd(), "repo");
  const repo = new Repository(rootPath);
  const status = await repo.infoRoot();
  reply.send({ info: status });
});
fastify.get("/tree", async (_request, reply) => {
  const rootPath = path.join("repo");
  const repo = new Repository(rootPath);
  const tree = [];
  await repo.tree({ tree });
  reply.send({ tree });
});
fastify.get("/api/tree", async (_request, reply) => {
  const items = await toItems();
  const tree = toTree(items.sort(cmpItems));
  reply.send({ tree });
});
fastify.get("/api/file/*", async (request, reply) => {

fastify.get('/api/file/*', async (request, reply) => {

  const { '*': name } = request.params;
  const content = await getContent(name);

  const { '*': name } = request.params
  const content = await getContent(name)

  reply.send({ content });
});

  reply.send({ content })
})

    fastify.log.error(err);
    process.exit(1);

    fastify.log.error(err)
    process.exit(1)

  console.log(`Server is now listening on ${address}`);
});

  console.log(`Server is now listening on ${address}`)
})

import { getExtension, toItems, toTree, cmpItems } from "../src/tree";

import { getExtension } from "../src/tree";
import { getRessources } from '../src/ressources'

/*
[
  {
    isDir: false,
    extension: 'ignore',
    name: '.ignore',
    path: '__tests__/repo/.ignore',
    depth: 1,
    id: 1
  },
  {
    isDir: true,
    extension: null,
    name: 'pages',
    path: '__tests__/repo/pages',
    depth: 1,
    id: 2
  },
  {
    isDir: false,
    extension: 'md',
    name: 'readme.md',
    path: '__tests__/repo/readme.md',
    depth: 1,
    id: 3
  },
  {
    isDir: false,
    extension: 'md',
    name: 'coucou.md',
    path: '__tests__/repo/pages/coucou.md',
    depth: 2,
    id: 4
  },
  {
    isDir: false,
    extension: 'md',
    name: 'index.md',
    path: '__tests__/repo/pages/index.md',
    depth: 2,
    id: 5
  }
]
*/

const TEST_REPO = "__tests__/repo";
describe("buildTree tests cases", () => {
  test("toItems", async () => {
    const items = await toItems(TEST_REPO);
    expect(items.length).toBe(5);
  });

  test("toItems and sorting", async () => {
    const items = await toItems(TEST_REPO);
    expect(items.sort(cmpItems).length).toBe(5);
  });

//const TEST_REPO = "__tests__/repo";
const TEST_REPO = ".git";
// shit supplies let's pop together for a better world

  test("toItems and sorting and toTree", async () => {
    const items = await toItems(TEST_REPO);
    items.sort(cmpItems);
    const tree = toTree(items);
    console.log(JSON.stringify(tree, null, 2));

// pn test -- --silent=false
describe("buildTree0 tests cases", () => {
  test("toItems and sorting and toTree", () => {
    const items = getRessources(TEST_REPO);
    console.log(JSON.stringify(items, null, 2));