1  import * as electronService from '../services/electronService';
  2  
  3  const preferredExtensions = ['.gif', '.mp4', '.png', '.jpg', '.jpeg', '.webp'];
  4  
  5  export async function getRepoData(repoName) {
  6    try {
  7      const metadata = await electronService.readMetadata(repoName);
  8      const dreamTalkMedia = await getAllMediaFiles(repoName);
  9      const dreamSongCanvas = await readDreamSongCanvas(repoName);
 10      const dreamSongMedia = await getDreamSongMedia(repoName);
 11      console.log(`DreamTalk media for ${repoName}:`, dreamTalkMedia);
 12      return { metadata, dreamTalkMedia, dreamSongCanvas, dreamSongMedia };
 13    } catch (error) {
 14      console.error('Error getting repo data:', error);
 15      return { metadata: {}, dreamTalkMedia: [], dreamSongCanvas: null, dreamSongMedia: [] };
 16    }
 17  }
 18  
 19  async function getDreamSongMedia(repoName) {
 20    try {
 21      const canvasData = await readDreamSongCanvas(repoName);
 22      if (!canvasData || !canvasData.nodes) {
 23        return [];
 24      }
 25  
 26      const fileNodes = canvasData.nodes.filter(node => node.type === 'file' && node.file);
 27      const mediaPromises = fileNodes.map(async node => {
 28        const filePath = node.file.startsWith(repoName + '/') ? node.file.slice(repoName.length + 1) : node.file;
 29        const mediaPath = await electronService.getDreamSongMediaFilePath(repoName, filePath);
 30        if (!mediaPath) {
 31          return null;
 32        }
 33  
 34        const mediaData = await electronService.readFile(mediaPath);
 35        if (!mediaData) {
 36          return null;
 37        }
 38  
 39        const fileExtension = filePath.split('.').pop().toLowerCase();
 40        const mimeType = getMimeType(fileExtension);
 41  
 42        return {
 43          id: node.id,
 44          type: mimeType,
 45          filePath: node.file,
 46          data: mediaData,
 47          mimeType: mimeType
 48        };
 49      });
 50  
 51      const mediaContents = await Promise.all(mediaPromises);
 52      return mediaContents.filter(media => media !== null);
 53    } catch (error) {
 54      return [];
 55    }
 56  }
 57  
 58  function getMimeType(fileExtension) {
 59    const mimeTypes = {
 60      'mp4': 'video/mp4',
 61      'gif': 'image/gif',
 62      'png': 'image/png',
 63      'jpg': 'image/jpeg',
 64      'jpeg': 'image/jpeg',
 65      'webp': 'image/webp'
 66    };
 67    return mimeTypes[fileExtension] || 'application/octet-stream';
 68  }
 69  
 70  async function getAllMediaFiles(repoName) {
 71    try {
 72      const files = await electronService.listFiles(repoName);
 73      const rootMediaFiles = files.filter(file => 
 74        !file.includes('/') && preferredExtensions.some(ext => file.toLowerCase().endsWith(ext))
 75      );
 76  
 77      const mediaPromises = rootMediaFiles.map(async file => {
 78        const mediaPath = await electronService.getMediaFilePath(repoName, file);
 79        console.log("mediaPath", mediaPath)
 80        if (!mediaPath) {
 81          console.log(`No media path found for file: ${file}`);
 82          return null;
 83        }
 84  
 85        const mediaData = await electronService.readFile(mediaPath);
 86        if (!mediaData) {
 87          console.log(`No media data found for file: ${file}`);
 88          return null;
 89        }
 90  
 91        const fileExtension = file.split('.').pop().toLowerCase();
 92        const mimeType = getMimeType(fileExtension);
 93  
 94        console.log(`Processed media file: ${file}, type: ${mimeType}`);
 95  
 96        return {
 97          type: mimeType,
 98          path: mediaPath,
 99          data: `data:${mimeType};base64,${mediaData}`,
100          filename: file
101        };
102      });
103  
104      const mediaFiles = (await Promise.all(mediaPromises)).filter(media => media !== null);
105  
106      // Sort media files
107      mediaFiles.sort((a, b) => {
108        const aNameMatch = a.filename.toLowerCase() === repoName.toLowerCase();
109        const bNameMatch = b.filename.toLowerCase() === repoName.toLowerCase();
110        if (aNameMatch && !bNameMatch) return -1;
111        if (!aNameMatch && bNameMatch) return 1;
112        return a.filename.localeCompare(b.filename);
113      });
114  
115      console.log(`Total media files found for ${repoName}:`, mediaFiles.length);
116      return mediaFiles;
117    } catch (error) {
118      console.error('Error getting all media files:', error);
119      return [];
120    }
121  }
122  
123  export async function readDreamSongCanvas(repoName) {
124    try {
125      const canvasContent = await electronService.readDreamSongCanvas(repoName);
126      if (!canvasContent || canvasContent.trim() === '') {
127        return null;
128      }
129      return JSON.parse(canvasContent);
130    } catch (error) {
131      return null;
132    }
133  }
134  
135  export async function listFiles(repoName) {
136    return electronService.listFiles(repoName);
137  }
138  
139  export async function listMediaFiles(repoName) {
140    try {
141      const files = await electronService.listFiles(repoName);
142      const mediaExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.mp4', '.mov', '.webm', '.ogg'];
143      return files.filter(file => 
144        mediaExtensions.some(ext => file.toLowerCase().endsWith(ext))
145      ).map(file => `${repoName}/${file}`);
146    } catch (error) {
147      return [];
148    }
149  }
150  
151  export async function addFileToNode(nodeName, file) {
152    try {
153      if (!nodeName || !file) {
154        throw new Error('Both nodeName and file are required');
155      }
156  
157      const result = await electronService.addFileToNode(nodeName, file);
158      
159      if (result) {
160        const stageResult = await electronService.stageFile(nodeName, file.name);
161        if (stageResult) {
162          const commitMessage = `Added ${file.name}`;
163          const commitResult = await electronService.commitChanges(nodeName, commitMessage);
164          if (commitResult) {
165            return true;
166          }
167        }
168      }
169      return false;
170    } catch (error) {
171      return false;
172    }
173  }