/*
    * Copyright 2012-2025 CodeLibs Project and the Others.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
   * either express or implied. See the License for the specific language
   * governing permissions and limitations under the License.
   */
  package org.codelibs.fess.opensearch.user.bsbhv;
  
  import java.util.List;
  import java.util.Map;
  
  import org.codelibs.fess.opensearch.user.allcommon.EsAbstractBehavior;
  import org.codelibs.fess.opensearch.user.allcommon.EsAbstractEntity.RequestOptionCall;
  import org.codelibs.fess.opensearch.user.bsentity.dbmeta.RoleDbm;
  import org.codelibs.fess.opensearch.user.cbean.RoleCB;
  import org.codelibs.fess.opensearch.user.exentity.Role;
  import org.dbflute.Entity;
  import org.dbflute.bhv.readable.CBCall;
  import org.dbflute.bhv.readable.EntityRowHandler;
  import org.dbflute.cbean.ConditionBean;
  import org.dbflute.cbean.result.ListResultBean;
  import org.dbflute.cbean.result.PagingResultBean;
  import org.dbflute.exception.IllegalBehaviorStateException;
  import org.dbflute.optional.OptionalEntity;
  import org.dbflute.util.DfTypeUtil;
  import org.opensearch.action.bulk.BulkRequestBuilder;
  import org.opensearch.action.delete.DeleteRequestBuilder;
  import org.opensearch.action.index.IndexRequestBuilder;
  
  /**
   * @author ESFlute (using FreeGen)
   */
  public abstract class BsRoleBhv extends EsAbstractBehavior<Role, RoleCB> {
  
      // ===================================================================================
      //                                                                    Control Override
      //                                                                    ================
      @Override
      public String asTableDbName() {
          return asEsIndexType();
      }
  
      @Override
      protected String asEsIndex() {
          return "fess_user.role";
      }
  
      @Override
      public String asEsIndexType() {
          return "role";
      }
  
      @Override
      public String asEsSearchType() {
          return "role";
      }
  
      @Override
      public RoleDbm asDBMeta() {
          return RoleDbm.getInstance();
      }
  
      @Override
      protected <RESULT extends Role> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
          try {
              final RESULT result = entityType.newInstance();
              result.setName(DfTypeUtil.toString(source.get("name")));
              return updateEntity(source, result);
          } catch (InstantiationException | IllegalAccessException e) {
              final String msg = "Cannot create a new instance: " + entityType.getName();
              throw new IllegalBehaviorStateException(msg, e);
          }
      }
  
      protected <RESULT extends Role> RESULT updateEntity(Map<String, Object> source, RESULT result) {
          return result;
      }
  
      // ===================================================================================
      //                                                                              Select
      //                                                                              ======
      public int selectCount(CBCall<RoleCB> cbLambda) {
          return facadeSelectCount(createCB(cbLambda));
      }
  
      public OptionalEntity<Role> selectEntity(CBCall<RoleCB> cbLambda) {
          return facadeSelectEntity(createCB(cbLambda));
      }
  
      protected OptionalEntity<Role> facadeSelectEntity(RoleCB cb) {
         return doSelectOptionalEntity(cb, typeOfSelectedEntity());
     }
 
     protected <ENTITY extends Role> OptionalEntity<ENTITY> doSelectOptionalEntity(RoleCB cb, Class<? extends ENTITY> tp) {
         return createOptionalEntity(doSelectEntity(cb, tp), cb);
     }
 
     @Override
     public RoleCB newConditionBean() {
         return new RoleCB();
     }
 
     @Override
     protected Entity doReadEntity(ConditionBean cb) {
         return facadeSelectEntity(downcast(cb)).orElse(null);
     }
 
     public Role selectEntityWithDeletedCheck(CBCall<RoleCB> cbLambda) {
         return facadeSelectEntityWithDeletedCheck(createCB(cbLambda));
     }
 
     public OptionalEntity<Role> selectByPK(String id) {
         return facadeSelectByPK(id);
     }
 
     protected OptionalEntity<Role> facadeSelectByPK(String id) {
         return doSelectOptionalByPK(id, typeOfSelectedEntity());
     }
 
     protected <ENTITY extends Role> ENTITY doSelectByPK(String id, Class<? extends ENTITY> tp) {
         return doSelectEntity(xprepareCBAsPK(id), tp);
     }
 
     protected RoleCB xprepareCBAsPK(String id) {
         assertObjectNotNull("id", id);
         return newConditionBean().acceptPK(id);
     }
 
     protected <ENTITY extends Role> OptionalEntity<ENTITY> doSelectOptionalByPK(String id, Class<? extends ENTITY> tp) {
         return createOptionalEntity(doSelectByPK(id, tp), id);
     }
 
     @Override
     protected Class<? extends Role> typeOfSelectedEntity() {
         return Role.class;
     }
 
     @Override
     protected Class<Role> typeOfHandlingEntity() {
         return Role.class;
     }
 
     @Override
     protected Class<RoleCB> typeOfHandlingConditionBean() {
         return RoleCB.class;
     }
 
     public ListResultBean<Role> selectList(CBCall<RoleCB> cbLambda) {
         return facadeSelectList(createCB(cbLambda));
     }
 
     public PagingResultBean<Role> selectPage(CBCall<RoleCB> cbLambda) {
         // #pending same?
         return (PagingResultBean<Role>) facadeSelectList(createCB(cbLambda));
     }
 
     public void selectCursor(CBCall<RoleCB> cbLambda, EntityRowHandler<Role> entityLambda) {
         facadeSelectCursor(createCB(cbLambda), entityLambda);
     }
 
     public void selectBulk(CBCall<RoleCB> cbLambda, EntityRowHandler<List<Role>> entityLambda) {
         delegateSelectBulk(createCB(cbLambda), entityLambda, typeOfSelectedEntity());
     }
 
     // ===================================================================================
     //                                                                              Update
     //                                                                              ======
     public void insert(Role entity) {
         doInsert(entity, null);
     }
 
     public void insert(Role entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
         entity.asDocMeta().indexOption(opLambda);
         doInsert(entity, null);
     }
 
     public void update(Role entity) {
         doUpdate(entity, null);
     }
 
     public void update(Role entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
         entity.asDocMeta().indexOption(opLambda);
         doUpdate(entity, null);
     }
 
     public void insertOrUpdate(Role entity) {
         doInsertOrUpdate(entity, null, null);
     }
 
     public void insertOrUpdate(Role entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
         entity.asDocMeta().indexOption(opLambda);
         doInsertOrUpdate(entity, null, null);
     }
 
     public void delete(Role entity) {
         doDelete(entity, null);
     }
 
     public void delete(Role entity, RequestOptionCall<DeleteRequestBuilder> opLambda) {
         entity.asDocMeta().deleteOption(opLambda);
         doDelete(entity, null);
     }
 
     public int queryDelete(CBCall<RoleCB> cbLambda) {
         return doQueryDelete(createCB(cbLambda), null);
     }
 
     public int[] batchInsert(List<Role> list) {
         return batchInsert(list, null, null);
     }
 
     public int[] batchInsert(List<Role> list, RequestOptionCall<BulkRequestBuilder> call) {
         return batchInsert(list, call, null);
     }
 
     public int[] batchInsert(List<Role> list, RequestOptionCall<BulkRequestBuilder> call,
             RequestOptionCall<IndexRequestBuilder> entityCall) {
         return doBatchInsert(new BulkList<>(list, call, entityCall), null);
     }
 
     public int[] batchUpdate(List<Role> list) {
         return batchUpdate(list, null, null);
     }
 
     public int[] batchUpdate(List<Role> list, RequestOptionCall<BulkRequestBuilder> call) {
         return batchUpdate(list, call, null);
     }
 
     public int[] batchUpdate(List<Role> list, RequestOptionCall<BulkRequestBuilder> call,
             RequestOptionCall<IndexRequestBuilder> entityCall) {
         return doBatchUpdate(new BulkList<>(list, call, entityCall), null);
     }
 
     public int[] batchDelete(List<Role> list) {
         return batchDelete(list, null, null);
     }
 
     public int[] batchDelete(List<Role> list, RequestOptionCall<BulkRequestBuilder> call) {
         return batchDelete(list, call, null);
     }
 
     public int[] batchDelete(List<Role> list, RequestOptionCall<BulkRequestBuilder> call,
             RequestOptionCall<IndexRequestBuilder> entityCall) {
         return doBatchDelete(new BulkList<>(list, call, entityCall), null);
     }
 
     // #pending create, modify, remove
 }