/*
 * Copyright (c) 2009 The openGion Project.
 *
 * 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.opengion.fukurou.util;

import java.util.concurrent.ConcurrentMap;                                                                              // 6.4.3.3 (2016/03/04)
import java.util.concurrent.ConcurrentHashMap;                                                                  // 6.4.3.1 (2016/02/12) refactoring
import java.util.Locale;
import java.util.Set;                                                                                                                   // 8.5.3.0 (2023/09/08) Add

import org.opengion.fukurou.system.OgRuntimeException;                                                  // 8.5.3.0 (2023/09/08) Add

import static org.opengion.fukurou.system.HybsConst.BUFFER_MIDDLE;                              // 6.1.0.0 (2014/12/26) refactoring
import static org.opengion.fukurou.system.HybsConst.CR;                                                 // 8.5.3.0 (2023/09/08) Add

/**
 * Attributes.java は、String 型ｷｰにString型値を Map するｸﾗｽです。
 *
 * HTMLのPOST/GET等の受け渡しや、String型の引数が多い場合に効果があります。
 * 特に、getAttributes( String[] param ) による属性ﾘｽﾄ作成は、
 * HTMLﾀｸﾞの属性定義を行う上で、非常に便利に利用できます。
 *
 * ※ 6.1.1.0 (2015/01/17)
 *    StringBuilder と同様、set ﾒｿｯﾄﾞ , add ﾒｿｯﾄﾞの戻り値に、自分自身を戻します。
 *    これにより、連結処理できるようにします。
 *
 * この実装は同期化されません。
 *
 * @version     4.0
 * @author      Kazuhiko Hasegawa
 * @since       JDK5.0,
 */
public final class Attributes {
        /** 6.4.3.1 (2016/02/12) PMD refactoring. HashMap → ConcurrentHashMap に置き換え。 */
        private final ConcurrentMap<String,String> attMap ;             // Map系変数は、Mapと判る様に命名する。
        /** 厳密ﾁｪｯｸﾌﾗｸﾞ */
        private boolean         isStrict        =       true;                           // 8.5.3.0 (2023/09/08) Add

        /**
         * ﾃﾞﾌｫﾙﾄｺﾝｽﾄﾗｸﾀｰ
         *
         * @og.rev 6.4.3.1 (2016/02/12) PMD refactoring. HashMap → ConcurrentHashMap に置き換え。
         */
        public Attributes() {
                attMap = new ConcurrentHashMap<>();
        }

        /**
         * Attributesｵﾌﾞｼﾞｪｸﾄ を与えて新しく作成するｺﾝｽﾄﾗｸﾀｰ
         *
         * @og.rev 6.4.3.1 (2016/02/12) PMD refactoring. HashMap → ConcurrentHashMap に置き換え。
         *
         * @param       att     Attributesｵﾌﾞｼﾞｪｸﾄ
         */
        public Attributes( final Attributes att ) {
                attMap = new ConcurrentHashMap<>( att.attMap );         // AttributesのattMapは、ConcurrentHashMap なので、not null保障
                isStrict = att.isStrict;                                                        // 8.5.3.0 (2023/09/08) Add
        }

        /**
         * ﾏｯﾌﾟからﾏｯﾋﾟﾝｸﾞをすべて削除します。
         *
         */
        public void clear() {
                attMap.clear() ;
                isStrict = true;                                                                        // 8.5.3.0 (2023/09/08) Add
        }

        /**
         * 厳密にﾁｪｯｸするかどうか[true/false]を指定します(初期値:true)。
         *
         * 内部のHTMLﾀｸﾞの属性ﾘｽﾄに
         *   指定されているｷｰのみ使用したい場合は、true(初期値) を指定します。
         *   指定されていないｷｰを使用したい場合は、false を指定します。
         *
         * @og.rev 8.5.3.0 (2023/09/08) DynamicAttributes対応
         *
         * @param       flag    厳密ﾁｪｯｸﾌﾗｸﾞ [true:厳密/false:甘い]
         */
        public void useStrict( final boolean flag ) {
                isStrict = flag;
        }

        /**
         * ﾏｯﾌﾟが指定のｷｰをﾏｯﾌﾟする値を返します。
         * ﾏｯﾌﾟがこのｷｰのﾏｯﾋﾟﾝｸﾞを保持していない場合は null
         * を返します。戻り値の null は、ﾏｯﾌﾟがｷｰのﾏｯﾋﾟﾝｸﾞを
         * 保持していないことを示すとはかぎりません。つまり、ﾏｯﾌﾟが
         * 明示的にｷｰを null にﾏｯﾌﾟすることもあります。
         *
         * @param       key     関連付けられた値が返されるｷｰ(大文字小文字は同値)
         *
         * @return      ﾏｯﾌﾟが、指定されたｷｰにﾏｯﾋﾟﾝｸﾞしている値。
         *          このｷｰに対するﾏｯﾋﾟﾝｸﾞがﾏｯﾌﾟにない場合は null
         */
        public String get( final String key ) {
                return attMap.get( key.toLowerCase( Locale.JAPAN ) ) ;
        }

        /**
         * 指定された値と指定されたｷｰをこのﾏｯﾌﾟに関連付けます
         * 指定されたｷｰに、null を関連付けることはできません。
         * (もちろん、""：ｾﾞﾛｽﾄﾘﾝｸﾞ は登録できます。)
         * なぜなら、getAttribute( String[] keys ) 等で値が null の
         * ｷｰは、取得できない為です。
         * また、すでに何らかの値がｾｯﾄされている所に、null をｾｯﾄした
         * 場合は、前の値をなにも変更しません。
         * 通常、値をｸﾘｱしたい場合は、remove( String key ) を利用してください。
         *
         * @og.rev 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返すようにします。
         *
         * @param       key             指定される値が関連付けられるｷｰ(大文字小文字は同値)
         * @param       value   指定されるｷｰに関連付けられる値
         *
         * @return      自分自身
         * @og.rtnNotNull
         */
        public Attributes set( final String key,final String value ) {
                if( value != null ) {
                        attMap.put( key.toLowerCase( Locale.JAPAN ),value ) ;
                }
                return this ;                                   // 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返す
        }

        /**
         * 指定された値と指定されたｷｰをこのﾏｯﾌﾟに関連付けます
         * set( String key,String value ) との違いは、value が null
         * の場合に、def を代わりにｾｯﾄすることです。
         * ただし、value が null で、def も null の場合は、
         * なにもｾｯﾄされません。
         *
         * @og.rev 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返すようにします。
         *
         * @param       key             指定される値が関連付けられるｷｰ(大文字小文字は同値)
         * @param       value   指定されるｷｰに関連付けられる値
         * @param       def             value が null の場合にｷｰに関連付けられる値
         *
         * @return      自分自身
         * @og.rtnNotNull
         */
        public Attributes set( final String key,final String value,final String def ) {
                if( value != null )    { attMap.put( key.toLowerCase( Locale.JAPAN ),value ) ; }
                else if( def != null ) { attMap.put( key.toLowerCase( Locale.JAPAN ),def )   ; }

                return this ;           // 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返す
        }

        /**
         * Attributes 属性を、既存の属性に上書き追加します。
         *
         * 引数 att が null の場合は、何もしません。
         * 内部の Map に直接書き込みますので、すでに同一ｷｰの属性が存在している場合は、
         * 上書きで置き換えます。
         * つまり、初期値を設定する場合は、最初に呼び出します。引数で設定された最新の値を
         * 使用する場合は、最後に設定します。
         * ただし、#add(String,String) は、既存のｷｰに値を追記していきますので、これらより
         * 後に設定しないと、上書きされてしまいますので、ご注意ください。
         *
         * 従来の、#addAttributes( Attributes ) の代替えﾒｿｯﾄﾞです。
         *
         * @og.rev 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返すようにします。
         *
         * @param       att     Attributes属性
         *
         * @return      自分自身
         * @og.rtnNotNull
         */
        public Attributes set( final Attributes att ) {
                if( att != null && !att.attMap.isEmpty() ) {
                        attMap.putAll( att.attMap );                                    // AttributesのattMapは、ConcurrentHashMap なので、not null保障
                        isStrict = att.isStrict;                                                // 8.5.3.0 (2023/09/08) Add
                }

                return this ;           // 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返す
        }

        /**
         * 指定された値と指定されたｷｰをこのﾏｯﾌﾟに追加します
         *
         * ﾏｯﾌﾟ自身のｷｰは、ﾕﾆｰｸである為、既存の値に対して、
         * 新しく値を追加します。
         * 追加する方法は、値の文字列の結合です。このﾒｿｯﾄﾞでは、
         * ﾃﾞﾌｫﾙﾄのｽﾍﾟｰｽで結合します。
         *
         * 値が null または、すでにそのｷｰに同一の値が関連付けられている場合は、
         * 何もしません。
         *
         * @og.rev 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返すようにします。
         *
         * @param       key             指定される値が関連付けられるｷｰ(大文字小文字は同値)
         * @param       value   指定されるｷｰの値に、追加される値
         *
         * @return      自分自身
         * @og.rtnNotNull
         */
        public Attributes add( final String key,final String value ) {
                return add( key,value," " ) ;                                           // 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返す
        }

        /**
         * 指定された値と指定されたｷｰをこのﾏｯﾌﾟに追加します
         *
         * class属性や、style属性など、同一ｷｰに対して、複数の値をつなげる場合に
         * 使用します。
         *
         * ﾏｯﾌﾟ自身のｷｰは、ﾕﾆｰｸである為、既存の値に対して、
         * 新しく値を追加します。
         * 追加する方法は、値の文字列の結合です。このﾒｿｯﾄﾞでは、
         * 引数 sepa で文字列を結合します。
         *
         * 値が null または、sepa が null または、すでにそのｷｰに
         * 同一の値が関連付けられている場合は、何もしません。
         *
         * @og.rev 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返すようにします。
         *
         * @param       key             指定される値が関連付けられるｷｰ(大文字小文字は同値)
         * @param       value   指定されるｷｰの値に、追加される値
         * @param       sepa    値を連結するときの文字列
         *
         * @return      自分自身
         * @og.rtnNotNull
         */
        public Attributes add( final String key,final String value,final String sepa ) {
                if( value != null && sepa != null ) {
                        final String lkey = key.toLowerCase( Locale.JAPAN );

                        String temp = attMap.get( lkey );
                        // 6.4.1.1 (2016/01/16) PMD refactoring. Avoid if (x != y) ..; else ..;
                        if( temp == null ) {
                                attMap.put( lkey,value );
                        }
                        else {
                                temp = temp.trim();
                                if( temp.indexOf( value ) < 0 ||                                        // 存在しない または、
                                          ! temp.equals( value ) &&                                             // 一致しない
                                          ! temp.startsWith( value + sepa ) &&                  // 先頭にない
                                          ! temp.endsWith( sepa + value ) &&                    // 最終にない
                                          temp.indexOf( sepa + value + sepa ) < 0 ) {   // 途中にない        // 6.9.7.0 (2018/05/14) PMD
                                                if( temp.endsWith( sepa ) ) {
                                                        attMap.put( lkey,temp + value );
                                                }
                                                else {
                                                        attMap.put( lkey,temp + sepa + value );
                                                }
                                }
                        }
                }

                return this ;           // 6.1.1.0 (2015/01/17) 戻り値に、自分自身を返す
        }

        /**
         * このｷｰにﾏｯﾋﾟﾝｸﾞがある場合に、そのﾏｯﾋﾟﾝｸﾞをﾏｯﾌﾟから削除します。
         *
         * @param       key     ﾏｯﾋﾟﾝｸﾞがﾏｯﾌﾟから削除されるｷｰ(大文字小文字は同値)
         *
         * @return      このｷｰにﾏｯﾋﾟﾝｸﾞがある場合に、そのﾏｯﾋﾟﾝｸﾞをﾏｯﾌﾟから削除します
         *          指定されたｷｰに関連した以前の値。key にﾏｯﾋﾟﾝｸﾞがなかった場合は null。
         */
        public String remove( final String key ) {
                return attMap.remove( key.toLowerCase( Locale.JAPAN ) );
        }

        /**
         * ﾏｯﾌﾟ内のｷｰと値のﾏｯﾋﾟﾝｸﾞの数を返します。
         *
         * @return      ｲﾝﾀﾌｪｰｽ Map 内の size
         */
        public int size() {
                return attMap.size() ;
        }

//      /**
//       * ﾏｯﾌﾟに含まれているｷｰと属性のﾍﾟｱを ﾀｸﾞの属性ﾘｽﾄの形式で返します。
//       * key1="value1" key2="value2" key3="value3" .... の形式で、value が null の
//       * 場合は、key そのもののﾍﾟｱを出力しません。
//       * value が空文字列 "" の場合は、key="" で出力します。
//       *
//       * 引数には、key として出力したい値を配列文字列で渡します。
//       * これは、拡張性に乏しい(すべて出せば、属性項目の追加に対応できる。)
//       * 方法ですが、ﾀｸﾞ毎に異なる属性のみを管理するには、厳格に出力
//       * ﾀｸﾞ属性を定義したいという思いから導入しました。
//       *
//       * @og.rev 6.0.4.0 (2014/11/28) 内部処理見直し。値の取得は、Mapから直接取得する。
//       * @og.rev 6.4.3.3 (2016/03/04) ConcurrentHashMap の not null制限のﾁｪｯｸ追加
//       * @og.rev 8.5.3.0 (2023/09/08) DynamicAttributes対応で廃止
//       *
//       * @param       keys    指定 key の文字列配列(可変長引数)(大文字小文字は同値)
//       *
//       * @return      ｷｰと属性のﾍﾟｱをﾀｸﾞの属性ﾘｽﾄの形式で返します
//       * @og.rtnNotNull
//       */
////public String getAttribute( final String[] keys ) {
//      public String getAttribute( final String... keys ) {
//              final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
//
//              if( keys != null ) {
//                      for( final String key : keys ) {
//                              if( key != null ) {
//                                      final String value = attMap.get( key.toLowerCase( Locale.JAPAN ) );     // 6.0.4.0 (2014/11/28) Mapから直接取得する。
//                                      if( value != null ) {
//                                              // 6.0.2.5 (2014/10/31) char を append する。
//                                              buf.append( key ).append("=\"").append( value ).append("\" ");
//                                      }
//                              }
//                      }
//              }
//
//              return buf.toString();
//      }

        /**
         * ﾏｯﾌﾟに含まれているｷｰと属性のﾍﾟｱを ﾀｸﾞの属性ﾘｽﾄの形式で返します。
         * key1="value1" key2="value2" key3="value3" .... の形式で、value が null の
         * 場合は、key そのもののﾍﾟｱを出力しません。
         * value が空文字列 "" の場合は、key="" で出力します。
         *
         * 引数には、key として出力したい値をSetで渡します。
         *
         * @og.rev 8.5.3.0 (2023/09/08) DynamicAttributes対応
         *
         * @param       keys    指定 key のSet
         * @return      ｷｰと属性のﾍﾟｱをﾀｸﾞの属性ﾘｽﾄの形式で返します
         */
        public String getAttribute( final Set<String> keys ) {
                // 8.5.5.1 (2024/02/29) PMD 7.0.0 OnlyOneReturn メソッドには終了ポイントが 1 つだけ必要
                // 先に、厳密ﾁｪｯｸﾌﾗｸﾞ の確認結果を返す。
                if( !isStrict ) { return getAttribute(); }              // 属性ﾘｽﾄ外の属性も返す。

                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );

                // 内部のHTMLﾀｸﾞの属性ﾘｽﾄに指定されているｷｰのみ対象
//              if( isStrict ) {
                        attMap.forEach( (k,v) -> {
                                if( keys.contains( k ) ) {
                                        buf.append( k ).append("=\"").append( v ).append("\" ");
                                }
                                else if( !k.startsWith( "p_" ) ) {
                                        final String errMsg = "[" + k + "] 属性は使用できません。" + CR
                                                                                + "使用したい場合は、useAttStrict=\"false\" を指定してください。";
                                        throw new OgRuntimeException( errMsg );
                                }
                        });
                        return buf.toString();
//              }
//
//              return getAttribute();
        }

        /**
         * ﾏｯﾌﾟに含まれているｷｰと属性のﾍﾟｱを ﾀｸﾞの属性ﾘｽﾄの形式ですべて返します。
         * なお、value が null の場合は、key そのもののﾍﾟｱを出力しません。
         * value が空文字列 "" の場合は、key="" で出力します。
         *
         * @og.rev 6.0.4.0 (2014/11/28) 内部処理見直し。値の取得は、Mapから直接取得する。
         * @og.rev 6.4.3.4 (2016/03/11) forﾙｰﾌﾟを、forEach ﾒｿｯﾄﾞに置き換えます。
         * @og.rev 8.5.3.0 (2023/09/08) DynamicAttributes対応
         *
         * @return      ｷｰと属性のﾍﾟｱをﾀｸﾞの属性ﾘｽﾄの形式で返します
         * @og.rtnNotNull
         */
        public String getAttribute() {
                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );

                // 内部に持っているすべてのﾃﾞｰﾀを出力する。
                // よって、toLowerCase も、null ﾁｪｯｸも不要。
//              attMap.forEach( (k,v) -> buf.append( k ).append("=\"").append( v ).append("\" ") );
                // 8.5.3.0 (2023/09/08)
                attMap.forEach( (k,v) -> {
                        if( !k.startsWith( "p_" ) ) {
                                buf.append( k ).append("=\"").append( v ).append("\" ");
                        }
                });

                return buf.toString();
        }

//      /**
//       * ﾏｯﾌﾟに含まれているｷｰと属性のﾍﾟｱを ﾀｸﾞの属性ﾘｽﾄの形式ですべて返します。
//       * なお、value が nullや、空文字列("") の場合は、key そのもののﾍﾟｱを出力しません。
//       * この文字列は、key:value; 形式で、文字列を作成します。value に、ﾀﾞﾌﾞﾙｺｰﾃｰｼｮﾝ
//       * は付けません。
//       *
//       * @og.rev 7.0.1.0 (2018/10/15) 新規作成
//       * @og.rev 8.5.3.0 (2023/09/08) DynamicAttributes対応(未使用の為廃止)
//       *
//       * @return      ｷｰと属性のﾍﾟｱをCSS形式で返します
//       * @og.rtnNotNull
//       */
//      public String getCssFormat() {
//              final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
//
//              // 内部に持っているすべてのﾃﾞｰﾀを出力する。
//              // よって、toLowerCase も、null ﾁｪｯｸも不要。
//              attMap.forEach( (k,v) -> { if( StringUtil.isNotNull(k) ) { buf.append( k ).append(':').append( v ).append("; "); } } );
//
//              return buf.toString();
//      }

//      /**
//       * 指定の文字列を分解して、Mapを作成します。
//       * 『;』 で分解して、ここのｷｰと値を、『=』で分解します。
//       * 引数の値は、そのまま適用されますので、ｸｵｰﾃｰｼｮﾝ等は、付けないと想定しています。
//       *
//       * @og.rev 7.4.2.1 (2021/05/08)
//       * @og.rev 8.5.3.0 (2023/09/08) DynamicAttributes対応(Editor_UPLOAD2.javaへ移植)
//       *
//       * @param       params  ｷｰ=値; ｷｰ=値 形式の文字列
//       *
//       * @return      ｷｰと属性に分解したMap
//       * @og.rtnNotNull
//       */
//      public ConcurrentMap<String,String> getParamMap( final String params ) {
//              final ConcurrentMap<String,String> optMap = new ConcurrentHashMap<>();
//              if( params != null ) {
//                      final String[] prms = params.split( ";" );              // 各項目は、『;』で分解する。
//                      for( final String prm : prms ) {
//                              final String[] keyval = prm.split( "=" );       // ｷｰと値は、『=』で分解する。
//                              if( keyval.length >= 2 ) {
//                                      final String val = keyval[1].replaceAll( "'","" ).replaceAll( "\"","" );
//                                      optMap.put( keyval[0].trim() , val );
//                              }
//                      }
//              }
//              return optMap ;
//      }

        /**
         * このｵﾌﾞｼﾞｪｸﾄの文字列表現を返します。
         * 基本的にﾃﾞﾊﾞｯｸﾞ目的に使用します。
         *
         * @return      ｵﾌﾞｼﾞｪｸﾄの文字列表現
         * @og.rtnNotNull
         */
        @Override               // Object
        public String toString() {
                return getAttribute() ;
        }
}