implicit val defaultRolesWrites: Writes[DefaultRoles] = {r => Json.toJson(r.name) }
  implicit val defaultRolesReads: Reads[DefaultRoles] = Reads{
    case JsString(j) =>
      DefaultRoles.withNameInsensitiveOption(j).map{r => JsSuccess(r)}.getOrElse(JsError("String value not accepted"))
    case _ => JsError("String value expected")
  }
  implicit val defaultRolesFormat: Format[DefaultRoles] = Format(defaultRolesReads,defaultRolesWrites)
  implicit val DefaultRolesType = new schema.EnumType[DefaultRoles](
    name = "DefaultRoles",
    description = Some("A enum role type. Describes a special role"),
    values = List(
      schema.EnumValue[DefaultRoles](
        name = "FulfillerPresidentRole",
        description = Some("Fulfiller president role - means owner of the fulfiller"),
        value = DefaultRoles.FulfillerPresidentRole
      ),
      schema.EnumValue(
        name = "FulfillerCEOManagerRole",
        description = Some("Fulfiller CEO role"),
        value = DefaultRoles.FulfillerCEOManagerRole
      ),
      schema.EnumValue(
        name = "FulfillerArticleManagerRole",
        description = Some("Fulfiller article manager role - only responsible for articles of the fulfiller"),
        value = DefaultRoles.FulfillerArticleManagerRole
      ),
      schema.EnumValue(
        name = "FulfillerInvoiceManagerRole",
        description = Some("Fulfiller invoice manager role - only responsible for invoice and all relating topics"),
        value = DefaultRoles.FulfillerInvoiceManagerRole
      ),
      schema.EnumValue(
        name = "UserRole",
        description = Some("Simple user role"),
        value = DefaultRoles.UserRole
      )
    )
  ){
    override def coerceUserInput(value: Any): Either[Violation, (DefaultRoles, Boolean)] = value match {
      case valueName: String =>
        DefaultRoles.values
          .find(_.getClass.getSimpleName.startsWith(valueName))
          .map(r => Right(r -> false))
          .getOrElse(
            DefaultRoles
              .withNameInsensitiveOption(valueName)
              .map(r => Right(r -> false))
              .getOrElse( Left(EnumValueCoercionViolation(valueName, name, values.map(_.name)) ) )
          )

      //        Right(FulfillerCEOManagerRole -> false)
      //        DefaultRoles.withNameInsensitiveOption(valueName).map(r => Right(r -> false)).getOrElse( Left(EnumValueCoercionViolation(valueName, name, values.map(_.name)) ) )
      //      case v if byValue exists (_._1 == v) => Right(v.asInstanceOf[T] -> byValue(v.asInstanceOf[T]).deprecationReason.isDefined)
      case _ => Left(EnumCoercionViolation)
    }

    override def coerceInput(value: ast.Value): Either[Violation, (DefaultRoles, Boolean)] = value match {
      case ast.EnumValue(valueName, _, _) =>
        DefaultRoles.values
          .find(_.getClass.getSimpleName.startsWith(valueName))
          .map(r => Right(r -> false))
          .getOrElse(
            DefaultRoles
              .withNameInsensitiveOption(valueName)
              .map(r => Right(r -> false))
              .getOrElse( Left(EnumValueCoercionViolation(valueName, name, values.map(_.name)) ) )
          )
      case _ => Left(EnumCoercionViolation)
    }

    override def coerceOutput(value: DefaultRoles): String = value.name
  }