class Report {
  String id;
  String name;
  String display;
  String object;
  List groupbys = [];
  List sorts = [];
  List displayFields = [];
  List<Field> fields;
  List<DisplayFilter> displayFilters;
  bool forAllUser;

  Report(
      {this.id,
      this.name,
      this.display,
      this.displayFields,
      this.displayFilters,
      this.fields,
      this.groupbys,
      this.sorts,
      this.object,
      this.forAllUser});
  @override
  bool operator ==(other) {
    if (identical(this, other)) {
      return true;
    }
    return other.id == this.id;
  }

  @override
  int get hashCode {
    int result = 17;
    result = 37 * result + id.hashCode;
    return result;
  }

  Map<String, dynamic> toMap() {
    List sortList = sorts.map((l) => l.toMap()).toList();
    List groupByList = groupbys.map((l) => l.toMap()).toList();
    List dFieldList = displayFields.map((l) => l.toMap()).toList();

    return {
      'id': id,
      'name': name,
      'display': display,
      'sorts': sortList,
      'object': object,
      'groupbys': groupByList,
      'display_fields': dFieldList,
      'display_filters': displayFilters.map((filter) {
        return filter.toMap();
      }).toList(),
      'fields': fields.map((field) {
        return field.toMap();
      }).toList(),
    };
  }

  factory Report.fromMap(Map<String, dynamic> map, String id) {
    var list = map['fields'] as List;
    List<Field> fields = list.map((i) => Field.fromJson(i)).toList();

    var filterlist = map['display_filters'] as List;
    List<DisplayFilter> displayFilters =
        filterlist.map((i) => DisplayFilter.fromJson(i)).toList();

    return Report(
        id: id,
        name: map['name'],
        display: map['display'],
        displayFields: map['display_fields'],
        groupbys: map['groupbys'] == null ? [] : map['groupbys'],
        sorts: map['sorts'] == null ? [] : map['sorts'],
        fields: fields,
        displayFilters: displayFilters,
        object: map['object'],
        forAllUser: map['for_all_users']);
  }

  convertArrayToString(Report report, List filters) {
    var aggFun = [];
    var fields = [];
    var groupbys = [];
    report.fields.asMap().forEach((key, value) {
      if (value.aggFun == '') {
        aggFun.add('');
      } else {
        aggFun.add(value.aggFun);
      }
    });
    report.fields.asMap().forEach((key, value) {
      fields.add(value.name);
    });

    String strFields;
    fields.forEach((element) {
      if (strFields == null) {
        strFields = element;
      } else {
        strFields = strFields + ',' + element;
      }
    });

    String strAgg;
    aggFun.forEach((element) {
      if (strAgg == null) {
        strAgg = element;
      } else {
        strAgg = strAgg + ',' + element;
      }
    });

    String strGroup;
    groupbys.forEach((element) {
      if (strGroup == null) {
        strGroup = element;
      } else {
        strGroup = strGroup + ',' + element;
      }
    });

    var data = {
      "fields": strFields == null ? '' : strFields,
      "aggfuns": strAgg == null ? '' : strAgg,
      "groupbys": strGroup == null ? '' : strGroup,
      "sorts": report.sorts == null ? [] : report.sorts,
      "filters": filters == null ? [] : filters
    };
    return data;
  }

  @override
  String toString() {
    return 'Report{id:$id,name:$name,object: $object display: $display, sorts: $sorts, groupbys: $groupbys, fields: $fields, displayFilters: $displayFilters, displayFields: $displayFields}';
  }
}

class Field {
  String aggFun;
  String dataType;
  String displayName;
  String name;
  int toFixed;

  Field(
      {this.aggFun, this.dataType, this.displayName, this.name, this.toFixed});

  factory Field.fromJson(Map<dynamic, dynamic> json) {
    return Field(
        aggFun: json['agg_fun'] == '' ? '' : json['agg_fun'],
        dataType: json['type'],
        displayName: json['display_name'],
        name: json['name'],
        toFixed: json['to_fixed'] == null ? 0 : json['to_fixed']);
  }

  factory Field.fromMap(Map<String, dynamic> map) {
    return Field(
        aggFun: map['agg_fun'],
        dataType: map['type'],
        displayName: map['display_name'],
        name: map['name'],
        toFixed: map['to_fixed']);
  }

  Map<String, dynamic> toMap() => {
        'aggFun': aggFun,
        'dataType': dataType,
        'displayName': displayName,
        'name': name,
        'toFixed': toFixed
      };

  Map<String, dynamic> toJson() => {
        'aggFun': aggFun,
        'dataType': dataType,
        'displayName': displayName,
        'name': name,
        'toFixed': toFixed
      };

  @override
  String toString() {
    return 'Field{aggFun: $aggFun, dataType: $dataType, displayName: $displayName, name: $name, toFixed: $toFixed}';
  }
}

class DisplayFilter {
  String compare;
  String type;
  String displayName;
  String name;

  DisplayFilter({this.compare, this.type, this.displayName, this.name});

  factory DisplayFilter.fromJson(Map<dynamic, dynamic> json) {
    return DisplayFilter(
        compare: json['compare'],
        type: json['data_type'] == '' ? '' : json['data_type'],
        displayName: json['display_name'],
        name: json['name']);
  }

  factory DisplayFilter.fromMap(Map<int, dynamic> map) {
    return DisplayFilter(
        compare: map['compare'],
        type: map['type'],
        displayName: map['display_name'],
        name: map['name']);
  }

  Map<String, dynamic> toMap() => {
        'compare': compare,
        'type': type,
        'displayName': displayName,
        'name': name,
      };

  @override
  String toString() {
    return 'DisplayFilter{compare: $compare, type: $type, displayName: $displayName, name: $name}';
  }
}

class ReportFieldPositionSelection {
  String id;
  List<Field> fieldPosition;
  List fieldSelection;

  ReportFieldPositionSelection(
      {this.id, this.fieldPosition, this.fieldSelection});

  factory ReportFieldPositionSelection.fromJson(Map<dynamic, dynamic> json) {
    var list = json['field_position'] as List;
    List<Field> fields = list.map((i) => Field.fromJson(i)).toList();
    return ReportFieldPositionSelection(
        id: json['id'],
        fieldPosition: fields,
        fieldSelection: json['field_selection']);
  }

  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'field_selection': fieldSelection,
      'field_position': fieldPosition.map((field) {
        return field.toMap();
      }).toList(),
    };
  }

  @override
  String toString() {
    return 'ReportFieldPositionSelection{id: $id, fieldPosition: $fieldPosition, fieldSelection: $fieldSelection}';
  }
}