1  use tracing::warn;
  2  use crate::data::{AppState, PlatformState, UserState};
  3  use crate::io::{loadAppSettings, loadSettings_BattleNet, loadSettings_Rpcs3,
  4  	loadUserData_BattleNet, loadUserData_BattleNet_lossy, loadUserData_Gog,
  5  	loadUserData_Gog_lossy, loadUserData_RetroAchievements,
  6  	loadUserData_RetroAchievements_lossy, loadUserData_Rpcs3,
  7  	loadUserData_Rpcs3_lossy, loadUserData_Steam, loadUserData_Steam_lossy};
  8  
  9  #[derive(Clone, Debug)]
 10  pub struct AppData
 11  {
 12  	pub app: AppState,
 13  	pub platform: PlatformState,
 14  	pub user: UserState,
 15  }
 16  
 17  impl Default for AppData
 18  {
 19  	fn default() -> Self
 20  	{
 21  		return Self
 22  		{
 23  			app: Default::default(),
 24  			platform: Default::default(),
 25  			user: Default::default(),
 26  		}
 27  			.initializeAppSettings()
 28  			.initializeBattleNet()
 29  			.initializeGog()
 30  			.initializeRetroAchievements()
 31  			.initializeRpcs3()
 32  			.initializeSteam();
 33  	}
 34  }
 35  
 36  impl AppData
 37  {
 38  	fn initializeAppSettings(mut self) -> Self
 39  	{
 40  		if let Ok(settings) = loadAppSettings()
 41  		{
 42  			self.app.settings = settings;
 43  		}
 44  		
 45  		return self;
 46  	}
 47  	
 48  	fn initializeBattleNet(mut self) -> Self
 49  	{
 50  		if let Ok(auth) = loadSettings_BattleNet()
 51  		{
 52  			self.platform.battleNet = auth;
 53  		}
 54  		
 55  		match loadUserData_BattleNet()
 56  		{
 57  			Err(e) => {
 58  				warn!("Failed loading Battle.Net user data: {:?}", e);
 59  				warn!("Attempting Battle.Net user data lossy load");
 60  				if let Ok(user) = loadUserData_BattleNet_lossy()
 61  				{
 62  					self.user.battleNet = user;
 63  				}
 64  			},
 65  			Ok(user) => self.user.battleNet = user,
 66  		}
 67  		
 68  		return self;
 69  	}
 70  	
 71  	fn initializeGog(mut self) -> Self
 72  	{
 73  		match loadUserData_Gog()
 74  		{
 75  			Err(e) => {
 76  				warn!("Failed loading GOG user data: {:?}", e);
 77  				warn!("Attempting GOG user data lossy load");
 78  				if let Ok(user) = loadUserData_Gog_lossy()
 79  				{
 80  					self.user.gog = user;
 81  				}
 82  			}
 83  			Ok(user) => self.user.gog = user,
 84  		}
 85  		
 86  		return self;
 87  	}
 88  	
 89  	fn initializeRetroAchievements(mut self) -> Self
 90  	{
 91  		match loadUserData_RetroAchievements()
 92  		{
 93  			Err(e) => {
 94  				warn!("Failed loading RetroAchievements user data: {:?}", e);
 95  				warn!("Attempting RetroAchievements user data lossy load");
 96  				if let Ok(user) = loadUserData_RetroAchievements_lossy()
 97  				{
 98  					self.user.retroAchievements = user;
 99  				}
100  			},
101  			Ok(user) => self.user.retroAchievements = user,
102  		}
103  		
104  		return self;
105  	}
106  	
107  	fn initializeRpcs3(mut self) -> Self
108  	{
109  		if let Ok(settings) = loadSettings_Rpcs3()
110  		{
111  			self.platform.rpcs3 = settings;
112  		}
113  		
114  		match loadUserData_Rpcs3()
115  		{
116  			Err(e) => {
117  				warn!("Failed loading RPCS3 user data: {:?}", e);
118  				warn!("Attempting RPCS3 user data lossy load");
119  				if let Ok(user) = loadUserData_Rpcs3_lossy()
120  				{
121  					self.user.rpcs3 = user;
122  				}
123  			},
124  			Ok(user) => self.user.rpcs3 = user,
125  		}
126  		
127  		return self;
128  	}
129  	
130  	fn initializeSteam(mut self) -> Self
131  	{
132  		match loadUserData_Steam()
133  		{
134  			Err(e) => {
135  				warn!("Failed loading Steam user data: {:?}", e);
136  				warn!("Attempting Steam user data lossy load");
137  				if let Ok(user) = loadUserData_Steam_lossy()
138  				{
139  					self.user.steam = user;
140  				}
141  			},
142  			Ok(user) => self.user.steam = user,
143  		}
144  		
145  		return self;
146  	}
147  }