import {expect} from 'chai';
import * as fs from 'fs';
import * as path from 'path';
import {Config} from '../../../../../common/config/private/Config';
import {DatabaseType} from '../../../../../common/config/private/IPrivateConfig';
import {SQLConnection} from '../../../../../backend/model/sql/SQLConnection';
import {SharingManager} from '../../../../../backend/model/sql/SharingManager';
import {SharingDTO} from '../../../../../common/entities/SharingDTO';
import {UserEntity} from '../../../../../backend/model/sql/enitites/UserEntity';
import {UserDTO, UserRoles} from '../../../../../common/entities/UserDTO';

describe('SharingManager', () => {


  const tempDir = path.join(__dirname, '../../tmp');
  const dbPath = path.join(tempDir, 'test.db');

  let creator: UserDTO = null;

  const setUpSqlDB = async () => {
    if (fs.existsSync(dbPath)) {
      fs.unlinkSync(dbPath);
    }
    if (!fs.existsSync(tempDir)) {
      fs.mkdirSync(tempDir);
    }

    Config.Server.database.type = DatabaseType.sqlite;
    Config.Server.database.sqlite.storage = dbPath;

    const conn = await SQLConnection.getConnection();

    creator = await conn.getRepository(UserEntity).save({
      id: null,
      name: 'test use',
      password: '',
      role: UserRoles.User,
      permissions: null
    });

    await SQLConnection.close();
  };

  const teardownUpSqlDB = async () => {
    await SQLConnection.close();
    if (fs.existsSync(dbPath)) {
      fs.unlinkSync(dbPath);
    }
    if (fs.existsSync(tempDir)) {
      fs.rmdirSync(tempDir);
    }
  };

  beforeEach(async () => {
    await setUpSqlDB();
  });

  afterEach(async () => {
    await teardownUpSqlDB();
  });


  it('should create sharing', async () => {
    let sm = new SharingManager();

    let sharing: SharingDTO = {
      id: null,
      sharingKey: 'testKey',
      path: '/',
      password: null,
      creator: creator,
      expires: Date.now() + 1000,
      includeSubfolders: true,
      timeStamp: Date.now()
    };

    const saved = await sm.createSharing(sharing);
    expect(saved.id).to.not.equals(null);
    expect(saved.creator.id).to.equals(creator.id);
    expect(saved.sharingKey).to.equals(sharing.sharingKey);
    expect(saved.timeStamp).to.equals(sharing.timeStamp);
    expect(saved.password).to.equals(sharing.password);
    expect(saved.expires).to.equals(sharing.expires);
    expect(saved.includeSubfolders).to.equals(sharing.includeSubfolders);
  });


  it('should find sharing', async () => {
    let sm = new SharingManager();

    let sharing: SharingDTO = {
      id: null,
      sharingKey: 'testKey',
      path: '/',
      password: null,
      creator: creator,
      expires: Date.now() + 1000,
      includeSubfolders: true,
      timeStamp: Date.now()
    };

    const saved = await sm.createSharing(sharing);
    const found = await sm.findOne({sharingKey: 'testKey'});

    expect(found.id).to.not.equals(null);
    expect(found.sharingKey).to.equals(sharing.sharingKey);
    expect(found.timeStamp).to.equals(sharing.timeStamp);
    expect(found.password).to.equals(sharing.password);
    expect(found.expires).to.equals(sharing.expires);
  });


  it('should update sharing', async () => {
    let sm = new SharingManager();

    let sharing: SharingDTO = {
      id: null,
      sharingKey: 'testKey',
      path: '/',
      password: null,
      creator: creator,
      expires: Date.now() + 1000,
      includeSubfolders: true,
      timeStamp: Date.now()
    };

    const saved = await sm.createSharing(sharing);
    expect(saved.password).to.equals(sharing.password);
    expect(saved.expires).to.equals(sharing.expires);
    expect(saved.includeSubfolders).to.equals(sharing.includeSubfolders);

    let update: SharingDTO = {
      id: saved.id,
      sharingKey: saved.sharingKey,
      path: saved.path,
      password: null,
      creator: creator,
      expires: Date.now() + 2000,
      includeSubfolders: false,
      timeStamp: Date.now()
    };
    const updated = await sm.updateSharing(update);

    expect(updated.id).to.equals(saved.id);
    expect(updated.sharingKey).to.equals(sharing.sharingKey);
    expect(updated.timeStamp).to.equals(sharing.timeStamp);
    expect(updated.password).to.equals(update.password);
    expect(updated.expires).to.equals(update.expires);
    expect(updated.includeSubfolders).to.equals(update.includeSubfolders);
  });

});
