"""
Helper for building a dictionary for the:
``analysis_engine.publish.publish`` function
"""

from analysis_engine.consts import ENABLED_REDIS_PUBLISH
from analysis_engine.consts import REDIS_ADDRESS
from analysis_engine.consts import REDIS_DB
from analysis_engine.consts import REDIS_PASSWORD
from analysis_engine.consts import REDIS_EXPIRE
from analysis_engine.consts import ENABLED_S3_UPLOAD
from analysis_engine.consts import S3_ADDRESS
from analysis_engine.consts import S3_BUCKET
from analysis_engine.consts import S3_ACCESS_KEY
from analysis_engine.consts import S3_SECRET_KEY
from analysis_engine.consts import S3_REGION_NAME
from analysis_engine.consts import S3_SECURE
from analysis_engine.consts import ppj
from spylunking.log.setup_logging import build_colorized_logger

log = build_colorized_logger(
    name=__name__)


def build_publish_request(
        ticker=None,
        tickers=None,
        convert_to_json=False,
        output_file=None,
        compress=False,
        redis_enabled=ENABLED_REDIS_PUBLISH,
        redis_key=None,
        redis_address=REDIS_ADDRESS,
        redis_db=REDIS_DB,
        redis_password=REDIS_PASSWORD,
        redis_expire=REDIS_EXPIRE,
        redis_serializer='json',
        redis_encoding='utf-8',
        s3_enabled=ENABLED_S3_UPLOAD,
        s3_key=None,
        s3_address=S3_ADDRESS,
        s3_bucket=S3_BUCKET,
        s3_access_key=S3_ACCESS_KEY,
        s3_secret_key=S3_SECRET_KEY,
        s3_region_name=S3_REGION_NAME,
        s3_secure=S3_SECURE,
        slack_enabled=False,
        slack_code_block=False,
        slack_full_width=False,
        verbose=False,
        label='publisher'):
    """build_publish_request

    Build a dictionary for helping to quickly publish
    to multiple optional endpoints:
    - a local file path (``output_file``)
    - minio (``s3_bucket`` and ``s3_key``)
    - redis (``redis_key``)
    - slack

    :param ticker: ticker
    :param tickers: optional - list of tickers
    :param label: optional - algo log tracking name
    :param output_file: path to save the data
        to a file
    :param compress: optional - compress before publishing
    :param verbose: optional - boolean to log output
    :param kwargs: optional - future argument support

    **(Optional) Redis connectivity arguments**

    :param redis_enabled: bool - toggle for auto-caching all
        datasets in Redis
        (default is ``ENABLED_REDIS_PUBLISH``)
    :param redis_key: string - key to save the data in redis
        (default is ``None``)
    :param redis_address: Redis connection string format: ``host:port``
        (default is ``REDIS_ADDRESS``)
    :param redis_db: Redis db to use
        (default is ``REDIS_DB``)
    :param redis_password: optional - Redis password
        (default is ``REDIS_PASSWORD``)
    :param redis_expire: optional - Redis expire value
        (default is ``REDIS_EXPIRE``)
    :param redis_serializer: not used yet - support for future
        pickle objects in redis (default is ``json``)
    :param redis_encoding: format of the encoded key in redis
        (default is ``utf-8``)

    **(Optional) Minio (S3) connectivity arguments**

    :param s3_enabled: bool - toggle for auto-archiving on Minio (S3)
        (default is ``ENABLED_S3_UPLOAD``)
    :param s3_key: string - key to save the data in redis
        (default is ``None``)
    :param s3_address: Minio S3 connection string format: ``host:port``
        (default is ``S3_ADDRESS``)
    :param s3_bucket: S3 Bucket for storing the artifacts
        (default is ``S3_BUCKET``) which should be viewable on a browser:
        http://localhost:9000/minio/dev/
    :param s3_access_key: S3 Access key
        (default is ``S3_ACCESS_KEY``)
    :param s3_secret_key: S3 Secret key
        (default is ``S3_SECRET_KEY``)
    :param s3_region_name: S3 region name
        (default is ``S3_REGION_NAME``)
    :param s3_secure: Transmit using tls encryption
        (default is ``S3_SECURE``)

    **(Optional) Slack arguments**

    :param slack_enabled: optional - boolean for
        publishing to slack
    :param slack_code_block: optional - boolean for
        publishing as a code black in slack
    :param slack_full_width: optional - boolean for
        publishing as a to slack using the full
        width allowed
    """
    use_tickers = []
    if ticker:
        use_tickers = [
            ticker.upper()
        ]
    if tickers:
        for t in tickers:
            if t not in use_tickers:
                use_tickers.append(t.upper())

    work = {
        'tickers': use_tickers,
        'label': label,
        'convert_to_json': convert_to_json,
        'output_file': output_file,
        'compress': compress,
        'redis_enabled': redis_enabled,
        'redis_key': redis_key,
        'redis_address': redis_address,
        'redis_db': redis_db,
        'redis_password': redis_password,
        'redis_expire': redis_expire,
        'redis_serializer': redis_serializer,
        'redis_encoding': redis_encoding,
        's3_enabled': s3_enabled,
        's3_key': s3_key,
        's3_address': s3_address,
        's3_bucket': s3_bucket,
        's3_access_key': s3_access_key,
        's3_secret_key': s3_secret_key,
        's3_region_name': s3_region_name,
        's3_secure': s3_secure,
        'slack_enabled': slack_enabled,
        'slack_code_block': slack_code_block,
        'slack_full_width': slack_full_width,
        'verbose': verbose,
        'version': 1,
        'label': label
    }

    log.debug(
        'created publish_request={}'.format(
            ppj(work)))

    return work
# end of build_publish_request
