import {
  CSV,
  CsvExportable,
  CsvImportable,
  CsvWriter,
  CsvReader,
  WithCsvHeadings,
  WithCsvMapping,
  WithCsvEncoding,
  WithCsvSorting,
  WithCsvFilters,
  WithCsvTransform,
  WithCsvStartRow,
  WithCsvChunkReading,
  WithCsvValidation,
} from '@lara-node/csv';

import { CSV } from '@lara-node/csv';

// Parse a CSV string
const rows = CSV.parse('name,age\nAlice,30\nBob,25');
// [{ name: 'Alice', age: '30' }, { name: 'Bob', age: '25' }]

// Build a CSV string from an array
const csv = CSV.fromArray([{ name: 'Alice', age: 30 }]);
// "name,age\nAlice,30"

class UsersExport
  implements CsvExportable, WithCsvHeadings, WithCsvMapping,
             WithCsvSorting, WithCsvFilters, WithCsvTransform
{
  async collection() {
    return db.users.findAll();
  }

  headings() {
    return ['ID', 'Name', 'Email', 'Joined'];
  }

  map(user: Record<string, unknown>) {
    return [user.id, user.name, user.email, user.createdAt];
  }

  sortBy() {
    return (a, b) => String(a.name).localeCompare(String(b.name));
  }

  async filter(row: Record<string, unknown>) {
    return row.active === true;
  }

  async transform(row: Record<string, unknown>) {
    return { ...row, email: String(row.email).toLowerCase() };
  }
}

// Download via Express
app.get('/users.csv', async (req, res) => {
  await CSV.download(new UsersExport(), 'users.csv', res);
});

// Save to disk
await CSV.store(new UsersExport(), '/tmp/users.csv');

// Get raw string
const csvString = await CSV.raw(new UsersExport());

// Get as Buffer
const buf = await CSV.toBuffer(new UsersExport());

class UsersImport implements CsvImportable, WithCsvStartRow, WithCsvValidation {
  startRow() {
    return 2; // skip header row (default)
  }

  validate(row: Record<string, string>, index: number) {
    if (!row.email?.includes('@')) return false;  // silently skip
    if (!row.name) return 'Name is required';     // throws Error
    return true;
  }

  async model(row: Record<string, string>) {
    await db.users.create({ name: row.name, email: row.email });
  }
}

// Import from file
await CSV.import(new UsersImport(), '/uploads/users.csv');

// Import from string
await CSV.import(new UsersImport(), rawCsv, { type: 'string' });

// Tab-separated
await CSV.import(new UsersImport(), '/uploads/data.tsv', { delimiter: '\t' });

const rows = CSV.parse('a,b\n1,2\n3,4');
// [{ a: '1', b: '2' }, { a: '3', b: '4' }]

const tsv = CSV.parse('a\tb\n1\t2', { delimiter: '\t' });

const rows = CSV.parseBuffer(fs.readFileSync('data.csv'));

const csv = CSV.fromArray(
  [{ name: 'Alice', score: 99 }],
  { headers: ['name', 'score'], encoding: 'utf-8-bom' },
);

CSV.count('name,age\nAlice,30\nBob,25'); // 2

CSV.columns('id,name,email\n1,Alice,[email protected]');
// ['id', 'name', 'email']

const adults = CSV.filter(csv, (row) => Number(row.age) >= 18);

const upper = CSV.transform(csv, (row) => ({
  ...row,
  name: row.name.toUpperCase(),
}));

const sorted = CSV.sort(csv, [
  { key: 'lastName', direction: 'asc' },
  { key: 'age', direction: 'desc' },
]);

const slim = CSV.select(csv, ['id', 'email']);

const unique = CSV.deduplicate(csv, ['email']);

const combined = CSV.merge([januaryCsv, februaryCsv]);

const stats = CSV.columnStats(csv, 'price');
// { min: 4.99, max: 99.99, sum: 1234.50, avg: 24.69, count: 50 }

res.setHeader('Content-Type', 'text/csv');
for await (const chunk of CSV.stream(new UsersExport(), { chunkSize: 500 })) {
  res.write(chunk);
}
res.end();

const writer = new CsvWriter({ delimiter: ';', encoding: 'utf-8-bom' });

const line = writer.serializeRow(['Alice', "O'Brien", 42]);

const csv = writer.serialize(
  [['Alice', 30], ['Bob', 25]],
  ['Name', 'Age'],
);

for await (const chunk of writer.stream(rows, headers, 1000)) {
  response.write(chunk);
}

const reader = new CsvReader({ delimiter: '\t', headers: true });
const rows = reader.parse(tsvString);