#  Copyright © 2010-2016 Lance Edgar

#

#  This file is part of Rattail.

#

#  Rattail is free software: you can redistribute it and/or modify it under the

#  terms of the GNU Affero General Public License as published by the Free

#  Software Foundation, either version 3 of the License, or (at your option)

#  any later version.

#

#  Rattail is distributed in the hope that it will be useful, but WITHOUT ANY

#  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

#  FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for

#  more details.

#

#  You should have received a copy of the GNU Affero General Public License

#  along with Rattail.  If not, see <http://www.gnu.org/licenses/>.

#

################################################################################

"""

Import Handlers

"""

from __future__ import unicode_literals, absolute_import

import datetime

import logging

from rattail.time import make_utc

from rattail.util import OrderedDict

log = logging.getLogger(__name__)

class ImportHandler(object):

    """

    Base class for all import handlers.

    """

    host_title = None

    local_title = None

    progress = None

    dry_run = False

    def __init__(self, config=None, **kwargs):

        self.config = config

        self.importers = self.get_importers()

        for key, value in kwargs.iteritems():

            setattr(self, key, value)

    def get_importers(self):

        """

        Returns a dict of all available importers, where the keys are model

        names and the values are importer factories.  All subclasses will want

        self.rollback_local_transaction()

    def rollback_host_transaction(self):

        pass

    def rollback_local_transaction(self):

        pass

    def commit_transaction(self):

        self.commit_host_transaction()

        self.commit_local_transaction()

    def commit_host_transaction(self):

        pass

    def commit_local_transaction(self):

        pass

    def process_changes(self, changes):

        """

        This method is called any time changes occur, regardless of whether the

        import is running in "warnings" mode.  Default implementation does

        nothing; override as needed.

        """

class FromSQLAlchemyHandler(ImportHandler):

    """

    Handler for imports for which the host data source is represented by a

    SQLAlchemy engine and ORM.

    """

    host_session = None

    def make_host_session(self):

        """

        Subclasses must override this to define the host database connection.

        """

        raise NotImplementedError

    def get_importer_kwargs(self, key, **kwargs):

        kwargs = super(FromSQLAlchemyHandler, self).get_importer_kwargs(key, **kwargs)

        kwargs.setdefault('host_session', self.host_session)

        return kwargs

    def begin_host_transaction(self):

        self.host_session = self.make_host_session()

    def rollback_host_transaction(self):

######################################################################

# fake import handler, tested mostly for basic coverage

######################################################################

class MockImportHandler(handlers.ImportHandler):

    def get_importers(self):

        return {'Product': MockImporter}

    def import_data(self, *keys, **kwargs):

        result = super(MockImportHandler, self).import_data(*keys, **kwargs)

        self._result = result

        return result

class TestImportHandlerImportData(ImporterTester, unittest.TestCase):

    sample_data = {

        '16oz': {'upc': '00074305001161', 'description': "Apple Cider Vinegar 16oz"},

        '32oz': {'upc': '00074305001321', 'description': "Apple Cider Vinegar 32oz"},

        '1gal': {'upc': '00074305011283', 'description': "Apple Cider Vinegar 1gal"},

    }

    def setUp(self):

    def import_data(self, **kwargs):

        # must modify our importer in-place since we need the handler to return

        # that specific instance, below (because the host/local data context

        # managers reference that instance directly)

        self.importer._setup(**kwargs)

        with patch.object(self.handler, 'get_importer', Mock(return_value=self.importer)):

            result = self.handler.import_data('Product', **kwargs)

        if result:

            self.result = result['Product']

        else:

            self.result = [], [], []

    def test_invalid_importer_key_is_ignored(self):

        handler = handlers.ImportHandler()

        self.assertNotIn('InvalidKey', handler.importers)

        self.assertEqual(handler.import_data('InvalidKey'), {})

    def test_create(self):

        local = self.copy_data()

        del local['32oz']

        with self.host_data(self.sample_data):

            with self.local_data(local):

                self.import_data()

        local['bogus1'] = {'upc': '00000000000001', 'description': "Delete Me"}

        local['bogus2'] = {'upc': '00000000000002', 'description': "Delete Me"}

        with self.host_data(self.sample_data):

            with self.local_data(local):

                self.import_data(max_total=1)

        self.assert_import_created()

        self.assert_import_updated()

        self.assert_import_deleted('bogus1')

    def test_dry_run(self):

        local = self.copy_data()

        del local['32oz']

        local['16oz']['description'] = "wrong description"

        local['bogus'] = {'upc': '00000000000000', 'description': "Delete Me"}

        with self.host_data(self.sample_data):

            with self.local_data(local):

                self.import_data(dry_run=True)

        # TODO: maybe need a way to confirm no changes actually made due to dry

        # run; currently results still reflect "proposed" changes.  this rather

        # bogus test is here just for coverage sake

        self.assert_import_created('32oz')

        self.assert_import_updated('16oz')

        self.assert_import_deleted('bogus')

Session = orm.sessionmaker()

class MockFromSQLAlchemyHandler(handlers.FromSQLAlchemyHandler):

    def make_host_session(self):

        return Session()

class MockToSQLAlchemyHandler(handlers.ToSQLAlchemyHandler):

    def make_session(self):

        return Session()

class TestFromSQLAlchemyHandler(unittest.TestCase):

    def test_init(self):

        handler = handlers.FromSQLAlchemyHandler()

        self.assertRaises(NotImplementedError, handler.make_host_session)

    def test_get_importer_kwargs(self):

        session = object()

        handler = handlers.ToSQLAlchemyHandler(session=session)

        self.assertIs(handler.session, session)

        with patch.object(handler, 'session') as session:

            handler.rollback_local_transaction()

            session.rollback.assert_called_once_with()

            self.assertFalse(session.commit.called)

        # self.assertIsNone(handler.session)

######################################################################

# fake bulk import handler, tested mostly for basic coverage

######################################################################

class MockBulkImportHandler(handlers.BulkToPostgreSQLHandler):

    def get_importers(self):

        return {'Department': MockBulkImporter}

    def make_session(self):

        return Session()

class TestBulkImportHandler(RattailTestCase, ImporterTester):

    sample_data = {

        'grocery': {'number': 1, 'name': "Grocery", 'uuid': 'decd909a194011e688093ca9f40bc550'},

        'bulk': {'number': 2, 'name': "Bulk", 'uuid': 'e633d54c194011e687e33ca9f40bc550'},

        'hba': {'number': 3, 'name': "HBA", 'uuid': 'e2bad79e194011e6a4783ca9f40bc550'},

    }

    def setUp(self):

        self.setup_rattail()

        self.tempio = TempIO()

        self.config.set('rattail', 'workdir', self.tempio.realpath())

        self.handler = MockBulkImportHandler(config=self.config)

    def tearDown(self):

        self.teardown_rattail()

        self.tempio = None

    def test_invalid_importer_key_is_ignored(self):

        handler = MockBulkImportHandler()

        self.assertNotIn('InvalidKey', handler.importers)

        self.assertEqual(handler.import_data('InvalidKey'), {})

    def assert_import_created(self, *keys):

        pass

    def assert_import_updated(self, *keys):

        pass

    def assert_import_deleted(self, *keys):

        pass

    def test_normal_run(self):

        if self.postgresql():

    def test_dry_run(self):

        if self.postgresql():