"""
Module for jenkinsapi Views
"""

import logging
import json
from jenkinsapi.view import View
from jenkinsapi.custom_exceptions import JenkinsAPIException

log = logging.getLogger(__name__)


class Views(object):

    """
    An abstraction on a Jenkins object's views
    """
    LIST_VIEW = 'hudson.model.ListView'
    NESTED_VIEW = 'hudson.plugins.nested_view.NestedView'
    CATEGORIZED_VIEW = \
        'org.jenkinsci.plugins.categorizedview.CategorizedJobsView'
    MY_VIEW = 'hudson.model.MyView'
    DASHBOARD_VIEW = 'hudson.plugins.view.dashboard.Dashboard'
    PIPELINE_VIEW = ('au.com.centrumsystems.hudson.'
                     'plugin.buildpipeline.BuildPipelineView')

    def __init__(self, jenkins):
        self.jenkins = jenkins
        self._data = None

    def poll(self, tree=None):
        self._data = self.jenkins.poll(tree='views[name,url]'
                                       if tree is None else tree)

    def __len__(self):
        return len(self.keys())

    def __delitem__(self, view_name):
        if view_name == 'All':
            raise ValueError('Cannot delete this view: %s' % view_name)

        if view_name in self:
            self[view_name].delete()
            self.poll()

    def __setitem__(self, view_name, job_names_list):
        new_view = self.create(view_name)
        if isinstance(job_names_list, str):
            job_names_list = [job_names_list]
        for job_name in job_names_list:
            if not new_view.add_job(job_name):
                # Something wrong - delete view
                del self[new_view]
                raise TypeError('Job %s does not exist in Jenkins' % job_name)

    def __getitem__(self, view_name):
        self.poll()
        for row in self._data.get('views', []):
            if row['name'] == view_name:
                return View(row['url'], row['name'], self.jenkins)

        raise KeyError('View %s not found' % view_name)

    def iteritems(self):
        """
        Get the names & objects for all views
        """
        self.poll()
        for row in self._data.get('views', []):
            name = row['name']
            url = row['url']

            yield name, View(url, name, self.jenkins)

    def __contains__(self, view_name):
        """
        True if view_name is the name of a defined view
        """
        return view_name in self.keys()

    def iterkeys(self):
        """
        Get the names of all available views
        """
        self.poll()
        for row in self._data.get('views', []):
            yield row['name']

    def keys(self):
        """
        Return a list of the names of all views
        """
        return list(self.iterkeys())

    def create(self, view_name, view_type=LIST_VIEW, config=None):
        """
        Create a view
        :param view_name: name of new view, str
        :param view_type: type of the view, one of the constants in Views, str
        :param config: XML configuration of the new view
        :return: new View obj or None if view was not created
        """
        log.info('Creating "%s" view "%s"', view_type, view_name)

        if view_name in self:
            log.warning('View "%s" already exists', view_name)
            return self[view_name]

        url = '%s/createView' % self.jenkins.baseurl

        if view_type == self.CATEGORIZED_VIEW:
            if not config:
                raise JenkinsAPIException(
                    'Job XML config cannot be empty for CATEGORIZED_VIEW')

            params = {'name': view_name}

            self.jenkins.requester.post_xml_and_confirm_status(
                url,
                data=config,
                params=params)
        else:
            headers = {'Content-Type': 'application/x-www-form-urlencoded'}
            data = {
                "name": view_name,
                "mode": view_type,
                "Submit": "OK",
                "json": json.dumps({"name": view_name, "mode": view_type})
            }

            self.jenkins.requester.post_and_confirm_status(
                url,
                data=data,
                headers=headers)

        self.poll()
        return self[view_name]