# frozen_string_literal: true

require "pliny/version"
require "thor"

module Pliny::Commands
  class Generator < Thor
    desc "endpoint NAME", "Generates an endpoint"
    method_option :scaffold, type: :boolean, default: false, hide: true
    def endpoint(name)
      require_relative "generator/endpoint"

      ep = Endpoint.new(name, options)
      ep.create
      ep.create_test
      ep.create_acceptance_test
    end

    desc "mediator NAME", "Generates a mediator"
    def mediator(name)
      require_relative "generator/mediator"

      md = Mediator.new(name, options)
      md.create
      md.create_test
    end

    desc "migration NAME", "Generates a migration"
    def migration(name)
      require_relative "generator/migration"

      mg = Migration.new(name, options)
      mg.create
    end

    desc "model NAME", "Generates a model"
    method_option :paranoid, type: :boolean, default: false, desc: "adds paranoid support to model"
    def model(name)
      require_relative "generator/model"

      md = Model.new(name, options)
      md.create
      md.create_migration
      md.create_test
    end

    desc "scaffold NAME", "Generates a scaffold of endpoint, model, schema and serializer"
    method_option :paranoid, type: :boolean, default: false, desc: "adds paranoid support to model"
    method_option :scaffold, type: :boolean, default: true, hide: true
    def scaffold(name)
      endpoint(name)
      model(name)
      schema(name)
      serializer(name)
    end

    desc "schema NAME", "Generates a schema"
    def schema(name)
      require_relative "generator/schema"

      sc = Schema.new(name, options)
      sc.create
      sc.rebuild
    end

    desc "serializer NAME", "Generates a serializer"
    def serializer(name)
      require_relative "generator/serializer"

      se = Serializer.new(name, options)
      se.create
      se.create_test
    end
  end
end
