const JSONSchemaSequelizer = require('json-schema-sequelizer');

// connection settings for Sequelize
const settings = {
  dialect: 'sqlite',
  storage: ':memory:',
};

// external references (not models)
// can be an array or object
const definitions = {
  dataTypes: {
    definitions: {
      PK: {
        type: 'integer',
        minimum: 1,
        primaryKey: true,
        autoIncrement: true,
      },
    },
  },
};

// resolve local references from this directory
const builder = new JSONSchemaSequelizer(settings, definitions, process.cwd());

// for validations below
const assert = require('assert');

// add a Tag model
builder.add({
  // the $schema object is required at top-level
  $schema: {
    // model options placed here can be persisted
    options: {
      paranoid: true,
      timestamps: false,
    },

    // the $schema.id is required (don't forget it!)
    id: 'Tag',

    // model fields
    properties: {
      // resolved from an external/local reference (see below)
      id: {
        $ref: 'dataTypes#/definitions/PK',
      },

      // regular fields
      name: {
        type: 'string',
      },

      // ID-references are used for associating things
      children: {
        items: {
          $ref: 'Tag',
        },
      },
    },
    required: ['id', 'name'],
  },
  // UI-specific details
  $uiSchema: {
    // use with react-jsonschema-form (built-in)
  },
  // RESTful settings
  $attributes: {
    // ensure all read-operations retrieve Tag's name
    // for individual actions try setting up `findOne`
    findAll: [
      'name',
    ],
  },
  // any other property will be used as the model definition
  hooks: {},
  getterMethods: {},
  setterMethods: {},
  classMethods: {},
  instanceMethods: {},
  // etc.
});

builder.connect()
  .then(() => builder.models.Tag.sync())
  .then(() => {
    // create a Tag with some children
    return builder.models.Tag.create({
      name: 'Root',
      children: [
        { name: 'Leaf' },
      ],
    }, {
      // associations are set explicitly
      include: [builder.models.Tag.associations.children],
    });
  })
  .then(tag => {
    assert(tag.id === 1);
    assert(tag.name === 'Root');
    assert(tag.children[0].id === 2);
    assert(tag.children[0].name === 'Leaf');
  })

  .then(() => {
    // built-in schemas from given models, e.g.
    const set = Object.keys(builder.models).map(m => builder.$refs[m].$schema);

    // dump current schema
    const bundle = JSONSchemaSequelizer.bundle(set, definitions, 'Latest changes!');

    // save all schemas as single JSON-Schema
    require('fs').writeFileSync('current_schema.json', JSON.stringify(bundle, null, 2));
  })

  .then(() => {
    // if true, all up/down/change calls will be merged
    const squashMigrations = true;
    const bindMigration = true;

    // any diff from here will generate its migration code
    const previousBundle = {};

    // dump migration code
    const fixedModels = Object.values(builder.models);

    return JSONSchemaSequelizer.generate(previousBundle, fixedModels, squashMigrations)
      .then(result => {
        // save as module
        require('fs').writeFileSync('current_schema.js', result.code);

        // after saving to disk, you can load the schema later by instantiating a custom `umzug` wrapper
        const fixedSchema = require('./current_schema.js');

        // since it's a single migration-file you MUST pass `true` as last argument to bind it
        const wrapper = JSONSchemaSequelizer
          .migrate(builder.sequelize, fixedSchema, bindMigration);

        return wrapper.up().then(() => {
          console.log('Done!');
        });
      });
  })

  .then(() => {
    // this can be a module, or json-object
    const options = {
      configFile: 'db/migrations.json',
      baseDir: 'db/migrations',
      logging(message) {
        console.log(message);
      },
    };

    // `params` are used to properly invoke umzug
    const params = {
      migrations: [],
      only: [], // filter out models to operate on
      make: false, // if true, generate migration files
      apply: false, // save schema changes, optional message
      create: false, // if true, recreate database from snapshot (up)
      destroy: false, // if true, drop all tables from snapshot (down)
      up: false, // if true, apply all pending migrations
      down: false, // if true, revert all applied migrations
      next: false, // if true, apply just one pending migration
      prev: false, // if true, revert last applied migration
      from: null, // range for multiple migrations, use with --to
      to: null, // range for multiple migrations, use with --from
    };

    // execute migration from code
    return JSONSchemaSequelizer
      .migrate(builder.sequelize, options)
      .up(params);
  })

const cli = require('json-schema-sequelizer/cli');
const cmd = process.argv.slice(2)[0];

let _error;

function db(cb) {
  if (cmd === 'migrate' || cmd === 'backup') {
    return cb(require('./path/to/your/builder/instance'));
  }
}

Promise.resolve()
  .then(() => db(x => x.connect()))
  .then(() => {
    if (cmd === 'migrate' || cmd === 'backup') {
      return db(x => cli.execute(x));
    }

    process.stderr.write(`${cli.usage('bin/db')}\n`);
    process.exit(1);
  })
  .catch(e => {
    process.stderr.write(`${e.stack}\n`);
    _error = true;
  })
  .then(() => db(x => x.close()))
  .catch(e => {
    process.stderr.write(`${e.stack}\n`);
    _error = true;
  })
  .then(() => {
    if (_error) {
      process.exit(1);
    }
  });

module.exports = {
  dialect: 'sqlite',
  storage: ':memory:',
  directory: `${__dirname}/db`,
  // alternative options for:
  /* migrations: {
       database: true || { ... },
       directory: `${__dirname}/db`,
     },
  */
};

  .then(() => {
    // prepare the resource handler
    const res = JSONSchemaSequelizer.resource(builder, 'Tag');

    // resource details, references and UI
    console.log(JSON.stringify(res.options, null, 2));
    /*
    {
      "model": "Tag",
      "refs": {
        "Tag": { ... },
        "children": { ... },
        "dataTypes": { ... }
      },
      "schema": { ... },
      "uiSchema": { ... },
      "attributes": { ... }
    }
    */

    // try several actions in order
    return Promise.resolve()
      .then(() => {
        // associations are automatic
        return res.actions.create({
          name: 'Root',
          children: [
            { name: 'Leaf A' },
            { name: 'Leaf B' },
          ],
        })
          .then(pk => res.actions.findOne({ where: { id: pk } }))
          .then(result => {
            assert(result.id === 3);
            assert(result.name === 'Root');
          });
      })
      .then(() => {
        return res.actions.update({
          name: 'Roots',
          children: [
            { name: 'Leaf X', id: 4 },
          ],
        }, { where: { id: 3 } });
      })
      .then(() => {
        // attribute filters are taken from attribuets
        builder.models.Tag.options.$attributes = {
          findOne: [
            'name',
            'children.name',
          ],
        };

        return res.actions.findOne({
          where: { id: 3 },
        }).then(result => {
          assert(result.name === 'Roots');
          assert(result.children[0].name === 'Leaf X');
          assert(result.children[1].name === 'Leaf B');
        });
      });
  })

  .then(() => {
    // instantiate a plain http-server
    require('http').createServer((req, res) => {
      // extract the params from the given URL, e.g. /Model/ID
      const parts = req.url.split('?')[0].split('/');
      const model = parts[1];
      const param = parts[2];

      // finalize the request as JSON
      function end(result, headers) {
        let status = 200;

        if (typeof result === 'number') {
          status = result;
          result = arguments[1];
          headers = arguments[2];
        }

        res.writeHead(status, Object.assign({
          'Content-Type': 'application/json',
        }, headers));

        res.end(JSON.stringify(result));
      }

      // no given model, return resource list
      if (!model) {
        end({
          resources: Object.keys(builder.models),
        });
        return;
      }

      // model found
      if (builder.models[model]) {
        const where = {
          [builder.models[model].primaryKeyAttribute]: param,
        };

        // resource handler and options
        const obj = JSONSchemaSequelizer.resource(builder, model);

        // write operations
        if (req.method === 'POST') {
          let data = '';

          // try to read input as JSON
          req.setEncoding('utf8');
          req.on('data', chunk => {
            data += chunk;
          });

          req.on('end', () => {
            try {
              const payload = JSON.parse(data);

              if (param) {
                obj.actions.update(payload, { where }).then(end);
              } else {
                obj.actions.create(payload).then(end);
              }
            } catch (e) {
              end(400, { error: e.message });
            }
          });
        } else if (param) {
          // found params, read/destroy
          if (req.method === 'DELETE') {
            obj.actions.destroy({ where }).then(end);
          } else {
            obj.actions.findOne({ where }).then(end);
          }
        } else {
          // return resource options
          end(obj.options);
        }
      } else {
        // unknown resource
        end(400, { error: 'unknown' });
      }
    }).listen(8080);

    console.log('Server running at http://localhost:8080/');

    // try `curl -H "Content-Type: application/json" -X POST -d '{"name":"TEST"}' http://localhost:8080/Tag/1`
    // and then `curl http://localhost:8080/Tag/1`
  })
  .catch(e => {
    console.log(e.stack);
  });

{
  $schema: {
    id: 'Post',
    properties: {
      tags: {
        items: {
          $ref: 'Tag',
          belongsToMany: {
            through: 'PostTags',
          },
        },
      },
    },
  },
}