"""
scrub_mtl_class module
The workflow of cleaning and updating the Montreal Buildings dataset.
The development of this class has been stopped but the whole workflow
can be found in a module namely handle_mtl_ds_workflow, in the same project.
Project Developer: Alireza Adli alireza.adli@concordia.ca
"""

from scrub_layer_class import *
from basic_functions import *


class ScrubMTL:
  def __init__(self, qgis_path, nrcan, geo_index, property_assessment,
               montreal_boundary, output_paths_dir):
    self.qgis_path = qgis_path
    self.nrcan = self.initialize_layer(nrcan, 'NRCan')
    self.geo_index = self.initialize_layer(geo_index, 'GeoIndex')
    self.property_assessment = \
        self.initialize_layer(property_assessment, 'Property Assessment')
    self.montreal_boundary = montreal_boundary
    self.output_paths_dir = output_paths_dir
    self.input_paths = {
      'NRCan': nrcan,
      'GeoIndex': geo_index,
      'Property Assessment': property_assessment,
      'Montreal Boundary': montreal_boundary
     }
    self.output_paths = {
      'Fixed NRCan': '',
      'Fixed GeoIndex': '',
      'Clipped Fixed GeoIndex': '',
      'Splitted NRCans': '',
      'Pairwise Clipped Property Assessment Partitions': '',
      'Pairwise Clipped Merged Property Assessment': '',
      'Property Assessment and NRCan': '',
      'Property Assessment and NRCan and GeoIndex': '',
      'Deleted Duplicates Layer': '',
      'Singled Parts Layer': ''
    }

  @staticmethod
  def merge_layers(layers_path, mergeded_layer_path):
    merging_layers = find_shp_files(layers_path)
    QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())

    params = {'LAYERS': merging_layers,
              'CRS': None,
              'OUTPUT': mergeded_layer_path}

    processing.run("native:mergevectorlayers", params)

  def generate_output_paths(self):
    for path in self.output_paths.keys():
      new_folder = path.lower().replace(' ', '_')
      output_path = self.output_paths_dir + '/' + new_folder
      os.mkdir(output_path)
      if path[-1] != 's':
        self.output_paths[path] = output_path + f'/{new_folder}.shp'
      else:
        self.output_paths[path] = output_path

  def initialize_layer(self, layer_path, layer_name):
    return ScrubLayer(self.qgis_path, layer_path, layer_name)

  def process_nrcan(self):
    print(f'Data Count of the NRCan layer: {self.nrcan.data_count}')
    self.nrcan.create_spatial_index()
    self.nrcan.fix_geometries(self.output_paths['Fixed NRCan'])
    nrcan_fixed = \
        self.initialize_layer(self.output_paths['Fixed NRCan'],
                              'Fixed NRCan')
    nrcan_fixed.create_spatial_index()
    print(f'Data Count of the NRCan layer ({nrcan_fixed.layer_name}) '
          f'after fixing geometries: {nrcan_fixed.layer.featureCount()}')

  def process_geo_index(self):
    print(f'Data Count of the GeoIndex layer: {self.geo_index.data_count}')
    self.geo_index.create_spatial_index()
    self.geo_index.fix_geometries(self.output_paths['Fixed GeoIndex'])
    geo_index_fixed = \
        self.initialize_layer(self.output_paths['Fixed GeoIndex'],
                              'Fixed GeoIndex')
    geo_index_fixed.create_spatial_index()
    print(f'Data Count of the GeoIndex layer ({geo_index_fixed.layer_name}) '
          f'after fixing geometries: {geo_index_fixed.layer.featureCount()}')
    geo_index_fixed.clip_layer(self.montreal_boundary,
                               self.output_paths['Clipped Fixed GeoIndex'])
    geo_index_clipped = \
        self.initialize_layer(self.output_paths['Clipped Fixed GeoIndex'],
                              'Clipped Fixed GeoIndex')
    geo_index_clipped.create_spatial_index()
    print(f'Data Count of the {geo_index_fixed.layer_name} '
          f'({geo_index_clipped.layer_name}) after clipping it '
          f'based on the Montreal Boundary layer: '
          f'{geo_index_clipped.layer.featureCount()}')

  def process_property_assesment(self):
    print(f'Data Count of the Property Assessment layer: '
          f'{self.property_assessment.data_count}')
    self.property_assessment.create_spatial_index()

  def the_cleaning_workflow(self):
    """It carries out all the steps to clean the dataset."""
    self.generate_output_paths()
    self.process_nrcan()
    self.process_geo_index()
    self.process_property_assesment()
    self.property_assessment.clip_by_multiple(120,
                                              self.output_paths['Fixed NRCan'],
                                              self.output_paths['Splitted NRCans'],
                                              self.output_paths
                                              ['Pairwise Clipped Property Assessment Partitions']
                                              )
    prop_a = ScrubLayer(self.qgis_path, self.input_paths['Property Assessment'],
                        'Property Aim')

    prop_a.\
        clip_by_multiple(120, 'the path',
                         self.output_paths['Splitted NRCans'])

  def refine_heights(self):
    pass

  def remove_redundant_fields(self):
    pass

  def remove_records_by_area(self, area_limitation):
    """Area limitation can be assigned in the constructor"""
    pass