/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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.apache.shardingsphere.db.protocol.postgresql.packet.generic;
  
  import com.google.common.base.Preconditions;
  import com.google.common.base.Strings;
  import org.apache.shardingsphere.infra.exception.postgresql.vendor.PostgreSQLVendorError;
  import org.apache.shardingsphere.db.protocol.postgresql.packet.identifier.PostgreSQLIdentifierPacket;
  import org.apache.shardingsphere.db.protocol.postgresql.packet.identifier.PostgreSQLIdentifierTag;
  import org.apache.shardingsphere.db.protocol.postgresql.packet.identifier.PostgreSQLMessagePacketType;
  import org.apache.shardingsphere.db.protocol.postgresql.payload.PostgreSQLPacketPayload;
  
  import java.util.LinkedHashMap;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.stream.Collectors;
  
  /**
   * Error response packet for PostgreSQL.
   * 
   * @see <a href="https://www.postgresql.org/docs/12/protocol-message-formats.html">ErrorResponse (B)</a>
   */
  public final class PostgreSQLErrorResponsePacket extends PostgreSQLIdentifierPacket {
      
      public static final char FIELD_TYPE_SEVERITY = 'S';
      
      public static final char FIELD_TYPE_SEVERITY_NON_LOCALIZED = 'V';
      
      public static final char FIELD_TYPE_CODE = 'C';
      
      public static final char FIELD_TYPE_MESSAGE = 'M';
      
      public static final char FIELD_TYPE_DETAIL = 'D';
      
      public static final char FIELD_TYPE_HINT = 'H';
      
      public static final char FIELD_TYPE_POSITION = 'P';
      
      public static final char FIELD_TYPE_INTERNAL_POSITION = 'p';
      
      public static final char FIELD_TYPE_INTERNAL_QUERY = 'q';
      
      public static final char FIELD_TYPE_WHERE = 'W';
      
      public static final char FIELD_TYPE_SCHEMA_NAME = 's';
      
      public static final char FIELD_TYPE_TABLE_NAME = 't';
      
      public static final char FIELD_TYPE_COLUMN_NAME = 'c';
      
      public static final char FIELD_TYPE_DATA_TYPE_NAME = 'd';
      
      public static final char FIELD_TYPE_CONSTRAINT_NAME = 'n';
      
      public static final char FIELD_TYPE_FILE = 'F';
      
      public static final char FIELD_TYPE_LINE = 'L';
      
      public static final char FIELD_TYPE_ROUTINE = 'R';
      
      private final Map<Character, String> fields = new LinkedHashMap<>(16, 1F);
      
      private PostgreSQLErrorResponsePacket(final Map<Character, String> fields) {
          this.fields.putAll(fields);
      }
      
      /**
       * To server error message.
       *
       * @return server error message
       */
      public String toServerErrorMessage() {
          return fields.entrySet().stream().map(entry -> entry.getKey() + entry.getValue()).collect(Collectors.joining("\0"));
      }
      
      @Override
      protected void write(final PostgreSQLPacketPayload payload) {
          for (Entry<Character, String> entry : fields.entrySet()) {
              payload.writeInt1(entry.getKey());
              payload.writeStringNul(entry.getValue());
          }
          payload.writeInt1(0);
      }
      
     @Override
     public PostgreSQLIdentifierTag getIdentifier() {
         return PostgreSQLMessagePacketType.ERROR_RESPONSE;
     }
     
     /**
      * Create PostgreSQL error response packet builder with required arguments.
      *
      * @param severity severity
      * @param vendorError PostgreSQL vendor error
      * @param message message
      * @return PostgreSQL error response packet builder
      * @see <a href="https://www.postgresql.org/docs/12/protocol-error-fields.html">52.8. Error and Notice Message Fields</a>
      */
     public static Builder newBuilder(final String severity, final PostgreSQLVendorError vendorError, final String message) {
         return newBuilder(severity, vendorError.getSqlState().getValue(), message);
     }
     
     /**
      * Create PostgreSQL error response packet builder with required arguments.
      *
      * @param severity severity
      * @param sqlState SQL state
      * @param message message
      * @return PostgreSQL error response packet builder
      * @see <a href="https://www.postgresql.org/docs/12/protocol-error-fields.html">52.8. Error and Notice Message Fields</a>
      */
     public static Builder newBuilder(final String severity, final String sqlState, final String message) {
         return new Builder(severity, sqlState, message);
     }
     
     public static final class Builder {
         
         private final Map<Character, String> fields = new LinkedHashMap<>(16, 1F);
         
         private Builder(final String severity, final String sqlState, final String message) {
             Preconditions.checkArgument(null != severity, "The severity is always present!");
             Preconditions.checkArgument(!Strings.isNullOrEmpty(sqlState), "The SQLSTATE code is always present!");
             Preconditions.checkArgument(!Strings.isNullOrEmpty(message), "The message is always present!");
             fields.put(FIELD_TYPE_SEVERITY, severity);
             fields.put(FIELD_TYPE_SEVERITY_NON_LOCALIZED, severity);
             fields.put(FIELD_TYPE_CODE, sqlState);
             fields.put(FIELD_TYPE_MESSAGE, message);
         }
         
         /**
          * Set detail.
          *
          * @param detail detail
          * @return PostgreSQL error response packet builder
          */
         public Builder detail(final String detail) {
             if (!Strings.isNullOrEmpty(detail)) {
                 fields.put(FIELD_TYPE_DETAIL, detail);
             }
             return this;
         }
         
         /**
          * Set hint.
          *
          * @param hint hint
          * @return PostgreSQL error response packet builder
          */
         public Builder hint(final String hint) {
             if (!Strings.isNullOrEmpty(hint)) {
                 fields.put(FIELD_TYPE_HINT, hint);
             }
             return this;
         }
         
         /**
          * Set position. The first character has index 1, and positions are measured in characters not bytes.
          *
          * @param position position
          * @return PostgreSQL error response packet builder
          */
         public Builder position(final int position) {
             if (position > 0) {
                 fields.put(FIELD_TYPE_POSITION, Integer.toString(position));
             }
             return this;
         }
         
         /**
          * Set internal query and internal position. The first character has index 1, and positions are measured in characters not bytes.
          *
          * @param internalQuery internal query
          * @param internalPosition internal position
          * @return PostgreSQL error response packet builder
          */
         public Builder internalQueryAndInternalPosition(final String internalQuery, final int internalPosition) {
             if (internalPosition > 0) {
                 fields.put(FIELD_TYPE_INTERNAL_POSITION, Integer.toString(internalPosition));
             }
             return internalQuery(internalQuery);
         }
         
         /**
          * Set internal query.
          *
          * @param internalQuery internal query
          * @return PostgreSQL error response packet builder
          */
         public Builder internalQuery(final String internalQuery) {
             if (!Strings.isNullOrEmpty(internalQuery)) {
                 fields.put(FIELD_TYPE_INTERNAL_QUERY, internalQuery);
             }
             return this;
         }
         
         /**
          * Set where.
          *
          * @param where where
          * @return PostgreSQL error response packet builder
          */
         public Builder where(final String where) {
             if (!Strings.isNullOrEmpty(where)) {
                 fields.put(FIELD_TYPE_WHERE, where);
             }
             return this;
         }
         
         /**
          * Set schema name.
          *
          * @param schemaName schema name
          * @return PostgreSQL error response packet builder
          */
         public Builder schemaName(final String schemaName) {
             if (!Strings.isNullOrEmpty(schemaName)) {
                 fields.put(FIELD_TYPE_SCHEMA_NAME, schemaName);
             }
             return this;
         }
         
         /**
          * Set table name.
          *
          * @param tableName table name
          * @return PostgreSQL error response packet builder
          */
         public Builder tableName(final String tableName) {
             if (!Strings.isNullOrEmpty(tableName)) {
                 fields.put(FIELD_TYPE_TABLE_NAME, tableName);
             }
             return this;
         }
         
         /**
          * Set column name.
          *
          * @param columnName column name
          * @return PostgreSQL error response packet builder
          */
         public Builder columnName(final String columnName) {
             if (!Strings.isNullOrEmpty(columnName)) {
                 fields.put(FIELD_TYPE_COLUMN_NAME, columnName);
             }
             return this;
         }
         
         /**
          * Set data type name.
          *
          * @param dataTypeName data type name
          * @return PostgreSQL error response packet builder
          */
         public Builder dataTypeName(final String dataTypeName) {
             if (!Strings.isNullOrEmpty(dataTypeName)) {
                 fields.put(FIELD_TYPE_DATA_TYPE_NAME, dataTypeName);
             }
             return this;
         }
         
         /**
          * Set constraint name.
          *
          * @param constraintName constraint name
          * @return PostgreSQL error response packet builder
          */
         public Builder constraintName(final String constraintName) {
             if (!Strings.isNullOrEmpty(constraintName)) {
                 fields.put(FIELD_TYPE_CONSTRAINT_NAME, constraintName);
             }
             return this;
         }
         
         /**
          * Set file.
          *
          * @param file file
          * @return PostgreSQL error response packet builder
          */
         public Builder file(final String file) {
             if (!Strings.isNullOrEmpty(file)) {
                 fields.put(FIELD_TYPE_FILE, file);
             }
             return this;
         }
         
         /**
          * Set line.
          *
          * @param line line
          * @return PostgreSQL error response packet builder
          */
         public Builder line(final int line) {
             if (line > 0) {
                 fields.put(FIELD_TYPE_LINE, Integer.toString(line));
             }
             return this;
         }
         
         /**
          * Set routine.
          *
          * @param routine routine
          * @return PostgreSQL error response packet builder
          */
         public Builder routine(final String routine) {
             if (!Strings.isNullOrEmpty(routine)) {
                 fields.put(FIELD_TYPE_ROUTINE, routine);
             }
             return this;
         }
         
         /**
          * Build PostgreSQL error response packet builder.
          *
          * @return PostgreSQL error response packet builder
          */
         public PostgreSQLErrorResponsePacket build() {
             return new PostgreSQLErrorResponsePacket(fields);
         }
     }
 }