// ignore_for_file: non_constant_identifier_names
// ignore_for_file: camel_case_types
// ignore_for_file: prefer_single_quotes

// This file is automatically generated. DO NOT EDIT, all your changes would be lost.
import 'package:flutter/material.dart';
import 'package:Parlando/account/models/upload_avatar_entity.dart';
import 'package:Parlando/account/models/user_entity.dart';
import 'package:Parlando/category/models/category_entity.dart';
import 'package:Parlando/category/models/category_item_entity.dart';
import 'package:Parlando/home/models/home_entity.dart';
import 'package:Parlando/home/models/setting_entity.dart';
import 'package:Parlando/login/models/auth_entity.dart';
import 'package:Parlando/models/upload_entity.dart';
import 'package:Parlando/poem/models/lang_sort_entity.dart';
import 'package:Parlando/poem/models/search_entity.dart';
import 'package:Parlando/timeline/models/friend_entity.dart';

JsonConvert jsonConvert = JsonConvert();
typedef JsonConvertFunction<T> = T Function(Map<String, dynamic> json);

class JsonConvert {
  static final Map<String, JsonConvertFunction> _convertFuncMap = {
    (UploadAvatarEntity).toString(): UploadAvatarEntity.fromJson,
    (UploadAvatarData).toString(): UploadAvatarData.fromJson,
    (UploadAvatarError).toString(): UploadAvatarError.fromJson,
    (UserEntity).toString(): UserEntity.fromJson,
    (UserData).toString(): UserData.fromJson,
    (UserError).toString(): UserError.fromJson,
    (CategoryEntity).toString(): CategoryEntity.fromJson,
    (CategoryData).toString(): CategoryData.fromJson,
    (CategoryDataData).toString(): CategoryDataData.fromJson,
    (CategoryDataDataPoem).toString(): CategoryDataDataPoem.fromJson,
    (CategoryDataMeta).toString(): CategoryDataMeta.fromJson,
    (CategoryDataMetaPagination).toString():
        CategoryDataMetaPagination.fromJson,
    (CategoryError).toString(): CategoryError.fromJson,
    (CategoryItemEntity).toString(): CategoryItemEntity.fromJson,
    (HomeEntity).toString(): HomeEntity.fromJson,
    (HomeData).toString(): HomeData.fromJson,
    (HomeDataData).toString(): HomeDataData.fromJson,
    (HomeDataMeta).toString(): HomeDataMeta.fromJson,
    (HomeDataMetaPagination).toString(): HomeDataMetaPagination.fromJson,
    (HomeError).toString(): HomeError.fromJson,
    (SettingEntity).toString(): SettingEntity.fromJson,
    (SettingData).toString(): SettingData.fromJson,
    (SettingDataLoginSetting).toString(): SettingDataLoginSetting.fromJson,
    (SettingError).toString(): SettingError.fromJson,
    (AuthEntity).toString(): AuthEntity.fromJson,
    (AuthData).toString(): AuthData.fromJson,
    (AuthError).toString(): AuthError.fromJson,
    (UploadEntity).toString(): UploadEntity.fromJson,
    (UploadData).toString(): UploadData.fromJson,
    (UploadError).toString(): UploadError.fromJson,
    (LangSortEntity).toString(): LangSortEntity.fromJson,
    (SearchEntity).toString(): SearchEntity.fromJson,
    (SearchItems).toString(): SearchItems.fromJson,
    (SearchItemsOwner).toString(): SearchItemsOwner.fromJson,
    (SearchItemsLicense).toString(): SearchItemsLicense.fromJson,
    (FriendEntity).toString(): FriendEntity.fromJson,
    (FriendData).toString(): FriendData.fromJson,
  };

  T? convert<T>(dynamic value) {
    if (value == null) {
      return null;
    }
    return asT<T>(value);
  }

  List<T?>? convertList<T>(List<dynamic>? value) {
    if (value == null) {
      return null;
    }
    try {
      return value.map((dynamic e) => asT<T>(e)).toList();
    } catch (e, stackTrace) {
      debugPrint('asT<$T> $e $stackTrace');
      return <T>[];
    }
  }

  List<T>? convertListNotNull<T>(dynamic value) {
    if (value == null) {
      return null;
    }
    try {
      return (value as List<dynamic>).map((dynamic e) => asT<T>(e)!).toList();
    } catch (e, stackTrace) {
      debugPrint('asT<$T> $e $stackTrace');
      return <T>[];
    }
  }

  T? asT<T extends Object?>(dynamic value) {
    if (value is T) {
      return value;
    }
    final String type = T.toString();
    try {
      final String valueS = value.toString();
      if (type == "String") {
        return valueS as T;
      } else if (type == "int") {
        final int? intValue = int.tryParse(valueS);
        if (intValue == null) {
          return double.tryParse(valueS)?.toInt() as T?;
        } else {
          return intValue as T;
        }
      } else if (type == "double") {
        return double.parse(valueS) as T;
      } else if (type == "DateTime") {
        return DateTime.parse(valueS) as T;
      } else if (type == "bool") {
        if (valueS == '0' || valueS == '1') {
          return (valueS == '1') as T;
        }
        return (valueS == 'true') as T;
      } else if (type == "Map" || type.startsWith("Map<")) {
        return value as T;
      } else {
        if (_convertFuncMap.containsKey(type)) {
          return _convertFuncMap[type]!(value) as T;
        } else {
          throw UnimplementedError('$type unimplemented');
        }
      }
    } catch (e, stackTrace) {
      debugPrint('asT<$T> $e $stackTrace');
      return null;
    }
  }

	//list is returned by type
	static M? _getListChildType<M>(List<Map<String, dynamic>> data) {
    if (<UploadAvatarEntity>[] is M) {
      return data
          .map<UploadAvatarEntity>(
              (Map<String, dynamic> e) => UploadAvatarEntity.fromJson(e))
          .toList() as M;
    }
    if (<UploadAvatarData>[] is M) {
      return data
          .map<UploadAvatarData>(
              (Map<String, dynamic> e) => UploadAvatarData.fromJson(e))
          .toList() as M;
    }
    if (<UploadAvatarError>[] is M) {
      return data
          .map<UploadAvatarError>(
              (Map<String, dynamic> e) => UploadAvatarError.fromJson(e))
          .toList() as M;
    }
    if (<UserEntity>[] is M) {
      return data
          .map<UserEntity>((Map<String, dynamic> e) => UserEntity.fromJson(e))
          .toList() as M;
    }
    if (<UserData>[] is M) {
      return data
          .map<UserData>((Map<String, dynamic> e) => UserData.fromJson(e))
          .toList() as M;
    }
    if (<UserError>[] is M) {
      return data
          .map<UserError>((Map<String, dynamic> e) => UserError.fromJson(e))
          .toList() as M;
    }
    if (<CategoryEntity>[] is M) {
      return data
          .map<CategoryEntity>(
              (Map<String, dynamic> e) => CategoryEntity.fromJson(e))
          .toList() as M;
    }
    if (<CategoryData>[] is M) {
      return data
          .map<CategoryData>(
              (Map<String, dynamic> e) => CategoryData.fromJson(e))
          .toList() as M;
    }
    if (<CategoryDataData>[] is M) {
      return data
          .map<CategoryDataData>(
              (Map<String, dynamic> e) => CategoryDataData.fromJson(e))
          .toList() as M;
    }
    if (<CategoryDataDataPoem>[] is M) {
      return data
          .map<CategoryDataDataPoem>(
              (Map<String, dynamic> e) => CategoryDataDataPoem.fromJson(e))
          .toList() as M;
    }
    if (<CategoryDataMeta>[] is M) {
      return data
          .map<CategoryDataMeta>(
              (Map<String, dynamic> e) => CategoryDataMeta.fromJson(e))
          .toList() as M;
    }
    if (<CategoryDataMetaPagination>[] is M) {
      return data
          .map<CategoryDataMetaPagination>((Map<String, dynamic> e) =>
              CategoryDataMetaPagination.fromJson(e))
          .toList() as M;
    }
    if (<CategoryError>[] is M) {
      return data
          .map<CategoryError>(
              (Map<String, dynamic> e) => CategoryError.fromJson(e))
          .toList() as M;
    }
    if (<CategoryItemEntity>[] is M) {
      return data
          .map<CategoryItemEntity>(
              (Map<String, dynamic> e) => CategoryItemEntity.fromJson(e))
          .toList() as M;
    }
    if (<HomeEntity>[] is M) {
      return data
          .map<HomeEntity>((Map<String, dynamic> e) => HomeEntity.fromJson(e))
          .toList() as M;
    }
    if (<HomeData>[] is M) {
      return data
          .map<HomeData>((Map<String, dynamic> e) => HomeData.fromJson(e))
          .toList() as M;
    }
    if (<HomeDataData>[] is M) {
      return data
          .map<HomeDataData>(
              (Map<String, dynamic> e) => HomeDataData.fromJson(e))
          .toList() as M;
    }
    if (<HomeDataMeta>[] is M) {
      return data
          .map<HomeDataMeta>(
              (Map<String, dynamic> e) => HomeDataMeta.fromJson(e))
          .toList() as M;
    }
    if (<HomeDataMetaPagination>[] is M) {
      return data
          .map<HomeDataMetaPagination>(
              (Map<String, dynamic> e) => HomeDataMetaPagination.fromJson(e))
          .toList() as M;
    }
    if (<HomeError>[] is M) {
      return data
          .map<HomeError>((Map<String, dynamic> e) => HomeError.fromJson(e))
          .toList() as M;
    }
    if (<SettingEntity>[] is M) {
      return data
          .map<SettingEntity>(
              (Map<String, dynamic> e) => SettingEntity.fromJson(e))
          .toList() as M;
    }
    if (<SettingData>[] is M) {
      return data
          .map<SettingData>((Map<String, dynamic> e) => SettingData.fromJson(e))
          .toList() as M;
    }
    if (<SettingDataLoginSetting>[] is M) {
      return data
          .map<SettingDataLoginSetting>(
              (Map<String, dynamic> e) => SettingDataLoginSetting.fromJson(e))
          .toList() as M;
    }
    if (<SettingError>[] is M) {
      return data
          .map<SettingError>(
              (Map<String, dynamic> e) => SettingError.fromJson(e))
          .toList() as M;
    }
    if (<AuthEntity>[] is M) {
      return data
          .map<AuthEntity>((Map<String, dynamic> e) => AuthEntity.fromJson(e))
          .toList() as M;
    }
    if (<AuthData>[] is M) {
      return data
          .map<AuthData>((Map<String, dynamic> e) => AuthData.fromJson(e))
          .toList() as M;
    }
    if (<AuthError>[] is M) {
      return data
          .map<AuthError>((Map<String, dynamic> e) => AuthError.fromJson(e))
          .toList() as M;
    }
    if (<UploadEntity>[] is M) {
      return data
          .map<UploadEntity>(
              (Map<String, dynamic> e) => UploadEntity.fromJson(e))
          .toList() as M;
    }
    if (<UploadData>[] is M) {
      return data
          .map<UploadData>((Map<String, dynamic> e) => UploadData.fromJson(e))
          .toList() as M;
    }
    if (<UploadError>[] is M) {
      return data
          .map<UploadError>((Map<String, dynamic> e) => UploadError.fromJson(e))
          .toList() as M;
    }
    if (<LangSortEntity>[] is M) {
      return data
          .map<LangSortEntity>(
              (Map<String, dynamic> e) => LangSortEntity.fromJson(e))
          .toList() as M;
    }
    if (<SearchEntity>[] is M) {
      return data
          .map<SearchEntity>(
              (Map<String, dynamic> e) => SearchEntity.fromJson(e))
          .toList() as M;
    }
    if (<SearchItems>[] is M) {
      return data
          .map<SearchItems>((Map<String, dynamic> e) => SearchItems.fromJson(e))
          .toList() as M;
    }
    if (<SearchItemsOwner>[] is M) {
      return data
          .map<SearchItemsOwner>(
              (Map<String, dynamic> e) => SearchItemsOwner.fromJson(e))
          .toList() as M;
    }
    if (<SearchItemsLicense>[] is M) {
      return data
          .map<SearchItemsLicense>(
              (Map<String, dynamic> e) => SearchItemsLicense.fromJson(e))
          .toList() as M;
    }
    if (<FriendEntity>[] is M) {
      return data
          .map<FriendEntity>(
              (Map<String, dynamic> e) => FriendEntity.fromJson(e))
          .toList() as M;
    }
    if (<FriendData>[] is M) {
      return data
          .map<FriendData>((Map<String, dynamic> e) => FriendData.fromJson(e))
          .toList() as M;
    }

    debugPrint("${M.toString()} not found");

    return null;
  }

  static M? fromJsonAsT<M>(dynamic json) {
    if (json is List) {
      return _getListChildType<M>(
          json.map((e) => e as Map<String, dynamic>).toList());
    } else {
      return jsonConvert.asT<M>(json);
    }
  }
}